|
| using | ProgressBar_p = ::std::shared_ptr< ProgressBar > |
| |
| using | ProgressBar_u = ::std::unique_ptr< ProgressBar > |
| |
| using | ProgressBar_w = ::std::weak_ptr< ProgressBar > |
| |
| using | ProgressBar_const_p = ::std::shared_ptr< const ProgressBar > |
| |
| using | ProgressBar_const_u = ::std::unique_ptr< const ProgressBar > |
| |
| using | ProgressBar_const_w = ::std::weak_ptr< const ProgressBar > |
| |
| template<typename T > |
| using | Packet = drjit::Packet< T, kSimdPacketSize > |
| |
| using | FloatP = Packet< float > |
| |
| using | DoubleP = Packet< double > |
| |
| using | IntP = Packet< int > |
| |
| template<typename T , int Dim> |
| using | VectorP = drjit::Array< Packet< T >, Dim > |
| |
| template<typename T > |
| using | Vector2P = VectorP< T, 2 > |
| |
| template<typename T > |
| using | Vector3P = VectorP< T, 3 > |
| |
| using | Vector2fP = Vector2P< float > |
| |
| using | Vector3fP = Vector3P< float > |
| |
| using | Vector2dP = Vector2P< double > |
| |
| using | Vector3dP = Vector3P< double > |
| |
| using | Mesh = MeshT< float > |
| |
| using | Meshd = MeshT< double > |
| |
| using | Mesh_p = ::std::shared_ptr< Mesh > |
| |
| using | Mesh_u = ::std::unique_ptr< Mesh > |
| |
| using | Mesh_w = ::std::weak_ptr< Mesh > |
| |
| using | Mesh_const_p = ::std::shared_ptr< const Mesh > |
| |
| using | Mesh_const_u = ::std::unique_ptr< const Mesh > |
| |
| using | Mesh_const_w = ::std::weak_ptr< const Mesh > |
| |
| using | Meshd_p = ::std::shared_ptr< Meshd > |
| |
| using | Meshd_u = ::std::unique_ptr< Meshd > |
| |
| using | Meshd_w = ::std::weak_ptr< Meshd > |
| |
| using | Meshd_const_p = ::std::shared_ptr< const Meshd > |
| |
| using | Meshd_const_u = ::std::unique_ptr< const Meshd > |
| |
| using | Meshd_const_w = ::std::weak_ptr< const Meshd > |
| |
| using | Mppca = MppcaT< float > |
| |
| using | Mppcad = MppcaT< double > |
| |
| using | Mppca_p = ::std::shared_ptr< Mppca > |
| |
| using | Mppca_u = ::std::unique_ptr< Mppca > |
| |
| using | Mppca_w = ::std::weak_ptr< Mppca > |
| |
| using | Mppca_const_p = ::std::shared_ptr< const Mppca > |
| |
| using | Mppca_const_u = ::std::unique_ptr< const Mppca > |
| |
| using | Mppca_const_w = ::std::weak_ptr< const Mppca > |
| |
| using | Mppcad_p = ::std::shared_ptr< Mppcad > |
| |
| using | Mppcad_u = ::std::unique_ptr< Mppcad > |
| |
| using | Mppcad_w = ::std::weak_ptr< Mppcad > |
| |
| using | Mppcad_const_p = ::std::shared_ptr< const Mppcad > |
| |
| using | Mppcad_const_u = ::std::unique_ptr< const Mppcad > |
| |
| using | Mppcad_const_w = ::std::weak_ptr< const Mppcad > |
| |
| using | Transform = TransformT< float > |
| |
| using | Transformd = TransformT< double > |
| |
| using | Transform_p = ::std::shared_ptr< Transform > |
| |
| using | Transform_u = ::std::unique_ptr< Transform > |
| |
| using | Transform_w = ::std::weak_ptr< Transform > |
| |
| using | Transform_const_p = ::std::shared_ptr< const Transform > |
| |
| using | Transform_const_u = ::std::unique_ptr< const Transform > |
| |
| using | Transform_const_w = ::std::weak_ptr< const Transform > |
| |
| using | Transformd_p = ::std::shared_ptr< Transformd > |
| |
| using | Transformd_u = ::std::unique_ptr< Transformd > |
| |
| using | Transformd_w = ::std::weak_ptr< Transformd > |
| |
| using | Transformd_const_p = ::std::shared_ptr< const Transformd > |
| |
| using | Transformd_const_u = ::std::unique_ptr< const Transformd > |
| |
| using | Transformd_const_w = ::std::weak_ptr< const Transformd > |
| |
| using | LowRankCovarianceMatrix = LowRankCovarianceMatrixT< float > |
| |
| using | LowRankCovarianceMatrixd = LowRankCovarianceMatrixT< double > |
| |
| using | LowRankCovarianceMatrix_p = ::std::shared_ptr< LowRankCovarianceMatrix > |
| |
| using | LowRankCovarianceMatrix_u = ::std::unique_ptr< LowRankCovarianceMatrix > |
| |
| using | LowRankCovarianceMatrix_w = ::std::weak_ptr< LowRankCovarianceMatrix > |
| |
| using | LowRankCovarianceMatrix_const_p = ::std::shared_ptr< const LowRankCovarianceMatrix > |
| |
| using | LowRankCovarianceMatrix_const_u = ::std::unique_ptr< const LowRankCovarianceMatrix > |
| |
| using | LowRankCovarianceMatrix_const_w = ::std::weak_ptr< const LowRankCovarianceMatrix > |
| |
| using | LowRankCovarianceMatrixd_p = ::std::shared_ptr< LowRankCovarianceMatrixd > |
| |
| using | LowRankCovarianceMatrixd_u = ::std::unique_ptr< LowRankCovarianceMatrixd > |
| |
| using | LowRankCovarianceMatrixd_w = ::std::weak_ptr< LowRankCovarianceMatrixd > |
| |
| using | LowRankCovarianceMatrixd_const_p = ::std::shared_ptr< const LowRankCovarianceMatrixd > |
| |
| using | LowRankCovarianceMatrixd_const_u = ::std::unique_ptr< const LowRankCovarianceMatrixd > |
| |
| using | LowRankCovarianceMatrixd_const_w = ::std::weak_ptr< const LowRankCovarianceMatrixd > |
| |
| using | GeneralizedLoss = GeneralizedLossT< float > |
| |
| using | GeneralizedLossd = GeneralizedLossT< double > |
| |
| using | GeneralizedLoss_p = ::std::shared_ptr< GeneralizedLoss > |
| |
| using | GeneralizedLoss_u = ::std::unique_ptr< GeneralizedLoss > |
| |
| using | GeneralizedLoss_w = ::std::weak_ptr< GeneralizedLoss > |
| |
| using | GeneralizedLoss_const_p = ::std::shared_ptr< const GeneralizedLoss > |
| |
| using | GeneralizedLoss_const_u = ::std::unique_ptr< const GeneralizedLoss > |
| |
| using | GeneralizedLoss_const_w = ::std::weak_ptr< const GeneralizedLoss > |
| |
| using | GeneralizedLossd_p = ::std::shared_ptr< GeneralizedLossd > |
| |
| using | GeneralizedLossd_u = ::std::unique_ptr< GeneralizedLossd > |
| |
| using | GeneralizedLossd_w = ::std::weak_ptr< GeneralizedLossd > |
| |
| using | GeneralizedLossd_const_p = ::std::shared_ptr< const GeneralizedLossd > |
| |
| using | GeneralizedLossd_const_u = ::std::unique_ptr< const GeneralizedLossd > |
| |
| using | GeneralizedLossd_const_w = ::std::weak_ptr< const GeneralizedLossd > |
| |
| using | SimdGeneralizedLoss = SimdGeneralizedLossT< float > |
| |
| using | SimdGeneralizedLossd = SimdGeneralizedLossT< double > |
| |
| using | SimdGeneralizedLoss_p = ::std::shared_ptr< SimdGeneralizedLoss > |
| |
| using | SimdGeneralizedLoss_u = ::std::unique_ptr< SimdGeneralizedLoss > |
| |
| using | SimdGeneralizedLoss_w = ::std::weak_ptr< SimdGeneralizedLoss > |
| |
| using | SimdGeneralizedLoss_const_p = ::std::shared_ptr< const SimdGeneralizedLoss > |
| |
| using | SimdGeneralizedLoss_const_u = ::std::unique_ptr< const SimdGeneralizedLoss > |
| |
| using | SimdGeneralizedLoss_const_w = ::std::weak_ptr< const SimdGeneralizedLoss > |
| |
| using | SimdGeneralizedLossd_p = ::std::shared_ptr< SimdGeneralizedLossd > |
| |
| using | SimdGeneralizedLossd_u = ::std::unique_ptr< SimdGeneralizedLossd > |
| |
| using | SimdGeneralizedLossd_w = ::std::weak_ptr< SimdGeneralizedLossd > |
| |
| using | SimdGeneralizedLossd_const_p = ::std::shared_ptr< const SimdGeneralizedLossd > |
| |
| using | SimdGeneralizedLossd_const_u = ::std::unique_ptr< const SimdGeneralizedLossd > |
| |
| using | SimdGeneralizedLossd_const_w = ::std::weak_ptr< const SimdGeneralizedLossd > |
| |
| template<typename T > |
| using | TransformListT = std::vector< TransformT< T > > |
| |
| using | TransformList = TransformListT< float > |
| |
| template<class T > |
| using | Map = Eigen::Map< T > |
| |
| template<class T > |
| using | Ref = Eigen::Ref< T > |
| |
| template<typename Scalar , int Dim> |
| using | Line = Eigen::ParametrizedLine< Scalar, Dim > |
| |
| template<typename Scalar , int Dim> |
| using | Plane = Eigen::Hyperplane< Scalar, Dim > |
| |
| template<typename Scalar , int Dim> |
| using | Box = Eigen::AlignedBox< Scalar, Dim > |
| |
| template<int Dim> |
| using | Boxf = Eigen::AlignedBox< float, Dim > |
| |
| template<int Dim> |
| using | Boxd = Eigen::AlignedBox< double, Dim > |
| |
| template<int Dim> |
| using | Boxi = Eigen::AlignedBox< std::int32_t, Dim > |
| |
| template<typename T > |
| using | Box2 = Eigen::AlignedBox< T, 2 > |
| |
| template<typename T > |
| using | Box3 = Eigen::AlignedBox< T, 3 > |
| |
| using | Box2f = Box2< float > |
| |
| using | Box3f = Box3< float > |
| |
| using | Box2d = Box2< double > |
| |
| using | Box3d = Box3< double > |
| |
| using | Box2i = Box2< std::int32_t > |
| |
| using | Box3i = Box3< std::int32_t > |
| |
| template<typename T > |
| using | MatrixX = Eigen::Matrix< T, Dynamic, Dynamic > |
| |
| using | MatrixXf = MatrixX< float > |
| |
| using | MatrixXd = MatrixX< double > |
| |
| using | MatrixXb = MatrixX< std::uint8_t > |
| |
| using | MatrixXs = MatrixX< std::uint16_t > |
| |
| using | MatrixXu = MatrixX< std::uint32_t > |
| |
| using | MatrixXi = MatrixX< std::int32_t > |
| |
| template<typename T > |
| using | Matrix0 = Eigen::Matrix< T, 0, 0 > |
| |
| template<typename T > |
| using | Matrix1 = Eigen::Matrix< T, 1, 1 > |
| |
| template<typename T > |
| using | Matrix2 = Eigen::Matrix< T, 2, 2 > |
| |
| template<typename T > |
| using | Matrix3 = Eigen::Matrix< T, 3, 3 > |
| |
| template<typename T > |
| using | Matrix4 = Eigen::Matrix< T, 4, 4 > |
| |
| template<typename T > |
| using | Matrix5 = Eigen::Matrix< T, 5, 5 > |
| |
| template<typename T > |
| using | Matrix6 = Eigen::Matrix< T, 6, 6 > |
| |
| using | Matrix0f = Matrix0< float > |
| |
| using | Matrix1f = Matrix1< float > |
| |
| using | Matrix2f = Matrix2< float > |
| |
| using | Matrix3f = Matrix3< float > |
| |
| using | Matrix4f = Matrix4< float > |
| |
| using | Matrix5f = Matrix5< float > |
| |
| using | Matrix6f = Matrix6< float > |
| |
| using | Matrix0d = Matrix0< double > |
| |
| using | Matrix1d = Matrix1< double > |
| |
| using | Matrix2d = Matrix2< double > |
| |
| using | Matrix3d = Matrix3< double > |
| |
| using | Matrix4d = Matrix4< double > |
| |
| using | Matrix5d = Matrix5< double > |
| |
| using | Matrix6d = Matrix6< double > |
| |
| using | Matrix0b = Matrix0< std::uint8_t > |
| |
| using | Matrix1b = Matrix1< std::uint8_t > |
| |
| using | Matrix2b = Matrix2< std::uint8_t > |
| |
| using | Matrix3b = Matrix3< std::uint8_t > |
| |
| using | Matrix4b = Matrix4< std::uint8_t > |
| |
| using | Matrix5b = Matrix5< std::uint8_t > |
| |
| using | Matrix6b = Matrix6< std::uint8_t > |
| |
| using | Matrix0s = Matrix0< std::uint16_t > |
| |
| using | Matrix1s = Matrix1< std::uint16_t > |
| |
| using | Matrix2s = Matrix2< std::uint16_t > |
| |
| using | Matrix3s = Matrix3< std::uint16_t > |
| |
| using | Matrix4s = Matrix4< std::uint16_t > |
| |
| using | Matrix5s = Matrix5< std::uint16_t > |
| |
| using | Matrix6s = Matrix6< std::uint16_t > |
| |
| using | Matrix0u = Matrix0< std::uint32_t > |
| |
| using | Matrix1u = Matrix1< std::uint32_t > |
| |
| using | Matrix2u = Matrix2< std::uint32_t > |
| |
| using | Matrix3u = Matrix3< std::uint32_t > |
| |
| using | Matrix4u = Matrix4< std::uint32_t > |
| |
| using | Matrix5u = Matrix5< std::uint32_t > |
| |
| using | Matrix6u = Matrix6< std::uint32_t > |
| |
| using | Matrix0i = Matrix0< std::int32_t > |
| |
| using | Matrix1i = Matrix1< std::int32_t > |
| |
| using | Matrix2i = Matrix2< std::int32_t > |
| |
| using | Matrix3i = Matrix3< std::int32_t > |
| |
| using | Matrix4i = Matrix4< std::int32_t > |
| |
| using | Matrix5i = Matrix5< std::int32_t > |
| |
| using | Matrix6i = Matrix6< std::int32_t > |
| |
| template<typename T > |
| using | Matrix3X = Eigen::Matrix< T, 3, Dynamic > |
| |
| using | Matrix3Xf = Matrix3X< float > |
| |
| using | Matrix3Xd = Matrix3X< double > |
| |
| using | Matrix3Xb = Matrix3X< std::uint8_t > |
| |
| using | Matrix3Xs = Matrix3X< std::uint16_t > |
| |
| using | Matrix3Xu = Matrix3X< std::uint32_t > |
| |
| using | Matrix3Xi = Matrix3X< std::int32_t > |
| |
| template<typename T > |
| using | MatrixX3 = Eigen::Matrix< T, Dynamic, 3 > |
| |
| using | MatrixX3f = MatrixX3< float > |
| |
| using | MatrixX3d = MatrixX3< double > |
| |
| using | MatrixX3b = MatrixX3< std::uint8_t > |
| |
| using | MatrixX3s = MatrixX3< std::uint16_t > |
| |
| using | MatrixX3u = MatrixX3< std::uint32_t > |
| |
| using | MatrixX3i = MatrixX3< std::int32_t > |
| |
| template<typename T , int N, int M = N> |
| using | RowMatrix = Eigen::Matrix< T, N, M, Eigen::RowMajor > |
| |
| template<typename T > |
| using | RowMatrixX = RowMatrix< T, Dynamic > |
| |
| template<typename T > |
| using | SparseMatrix = Eigen::SparseMatrix< T > |
| |
| using | SparseMatrixf = SparseMatrix< float > |
| |
| using | SparseMatrixd = SparseMatrix< double > |
| |
| using | SparseMatrixb = SparseMatrix< std::uint8_t > |
| |
| using | SparseMatrixs = SparseMatrix< std::uint16_t > |
| |
| using | SparseMatrixu = SparseMatrix< std::uint32_t > |
| |
| using | SparseMatrixi = SparseMatrix< std::int32_t > |
| |
| template<typename T > |
| using | SparseRowMatrix = Eigen::SparseMatrix< T, Eigen::RowMajor > |
| |
| using | SparseRowMatrixf = SparseRowMatrix< float > |
| |
| using | SparseRowMatrixd = SparseRowMatrix< double > |
| |
| using | SparseRowMatrixb = SparseRowMatrix< std::uint8_t > |
| |
| using | SparseRowMatrixs = SparseRowMatrix< std::uint16_t > |
| |
| using | SparseRowMatrixu = SparseRowMatrix< std::uint32_t > |
| |
| using | SparseRowMatrixi = SparseRowMatrix< std::int32_t > |
| |
| template<typename T , int Dim, int Options = 0> |
| using | Vector = Eigen::Matrix< T, Dim, 1, Options > |
| |
| template<typename T > |
| using | VectorX = Vector< T, Dynamic > |
| |
| using | VectorXf = VectorX< float > |
| |
| using | VectorXd = VectorX< double > |
| |
| using | VectorXb = VectorX< std::uint8_t > |
| |
| using | VectorXs = VectorX< std::uint16_t > |
| |
| using | VectorXu = VectorX< std::uint32_t > |
| |
| using | VectorXi = VectorX< std::int32_t > |
| |
| template<int Dim> |
| using | Vectorf = Vector< float, Dim > |
| |
| template<int Dim> |
| using | Vectord = Vector< double, Dim > |
| |
| template<int Dim> |
| using | Vectorb = Vector< std::uint8_t, Dim > |
| |
| template<int Dim> |
| using | Vectors = Vector< std::uint16_t, Dim > |
| |
| template<int Dim> |
| using | Vectoru = Vector< std::uint32_t, Dim > |
| |
| template<int Dim> |
| using | Vectori = Vector< std::int32_t, Dim > |
| |
| template<typename T > |
| using | Vector0 = Vector< T, 0 > |
| |
| template<typename T > |
| using | Vector1 = Vector< T, 1 > |
| |
| template<typename T > |
| using | Vector2 = Vector< T, 2 > |
| |
| template<typename T > |
| using | Vector3 = Vector< T, 3 > |
| |
| template<typename T > |
| using | Vector4 = Vector< T, 4 > |
| |
| template<typename T > |
| using | Vector5 = Vector< T, 5 > |
| |
| template<typename T > |
| using | Vector6 = Vector< T, 6 > |
| |
| template<typename T > |
| using | Vector7 = Vector< T, 7 > |
| |
| template<typename T > |
| using | Vector8 = Vector< T, 8 > |
| |
| using | Vector0f = Vector0< float > |
| |
| using | Vector1f = Vector1< float > |
| |
| using | Vector2f = Vector2< float > |
| |
| using | Vector3f = Vector3< float > |
| |
| using | Vector4f = Vector4< float > |
| |
| using | Vector5f = Vector5< float > |
| |
| using | Vector6f = Vector6< float > |
| |
| using | Vector7f = Vector7< float > |
| |
| using | Vector8f = Vector8< float > |
| |
| using | Vector0d = Vector0< double > |
| |
| using | Vector1d = Vector1< double > |
| |
| using | Vector2d = Vector2< double > |
| |
| using | Vector3d = Vector3< double > |
| |
| using | Vector4d = Vector4< double > |
| |
| using | Vector5d = Vector5< double > |
| |
| using | Vector6d = Vector6< double > |
| |
| using | Vector0b = Vector0< std::uint8_t > |
| |
| using | Vector1b = Vector1< std::uint8_t > |
| |
| using | Vector2b = Vector2< std::uint8_t > |
| |
| using | Vector3b = Vector3< std::uint8_t > |
| |
| using | Vector4b = Vector4< std::uint8_t > |
| |
| using | Vector5b = Vector5< std::uint8_t > |
| |
| using | Vector6b = Vector6< std::uint8_t > |
| |
| using | Vector0s = Vector0< std::uint16_t > |
| |
| using | Vector1s = Vector1< std::uint16_t > |
| |
| using | Vector2s = Vector2< std::uint16_t > |
| |
| using | Vector3s = Vector3< std::uint16_t > |
| |
| using | Vector4s = Vector4< std::uint16_t > |
| |
| using | Vector5s = Vector5< std::uint16_t > |
| |
| using | Vector6s = Vector6< std::uint16_t > |
| |
| using | Vector0u = Vector0< std::uint32_t > |
| |
| using | Vector1u = Vector1< std::uint32_t > |
| |
| using | Vector2u = Vector2< std::uint32_t > |
| |
| using | Vector3u = Vector3< std::uint32_t > |
| |
| using | Vector4u = Vector4< std::uint32_t > |
| |
| using | Vector5u = Vector5< std::uint32_t > |
| |
| using | Vector6u = Vector6< std::uint32_t > |
| |
| using | Vector0i = Vector0< std::int32_t > |
| |
| using | Vector1i = Vector1< std::int32_t > |
| |
| using | Vector2i = Vector2< std::int32_t > |
| |
| using | Vector3i = Vector3< std::int32_t > |
| |
| using | Vector4i = Vector4< std::int32_t > |
| |
| using | Vector5i = Vector5< std::int32_t > |
| |
| using | Vector6i = Vector6< std::int32_t > |
| |
| template<typename T , int Dim> |
| using | RowVector = Eigen::Matrix< T, 1, Dim > |
| |
| template<typename T > |
| using | RowVectorX = RowVector< T, Dynamic > |
| |
| using | RowVectorXf = RowVectorX< float > |
| |
| using | RowVectorXd = RowVectorX< double > |
| |
| using | RowVectorXb = RowVectorX< std::uint8_t > |
| |
| using | RowVectorXs = RowVectorX< std::uint16_t > |
| |
| using | RowVectorXu = RowVectorX< std::uint32_t > |
| |
| using | RowVectorXi = RowVectorX< std::int32_t > |
| |
| template<typename T > |
| using | RowVector0 = RowVector< T, 0 > |
| |
| template<typename T > |
| using | RowVector1 = RowVector< T, 1 > |
| |
| template<typename T > |
| using | RowVector2 = RowVector< T, 2 > |
| |
| template<typename T > |
| using | RowVector3 = RowVector< T, 3 > |
| |
| template<typename T > |
| using | RowVector4 = RowVector< T, 4 > |
| |
| template<typename T > |
| using | RowVector5 = RowVector< T, 5 > |
| |
| template<typename T > |
| using | RowVector6 = RowVector< T, 6 > |
| |
| using | RowVector0f = RowVector0< float > |
| |
| using | RowVector1f = RowVector1< float > |
| |
| using | RowVector2f = RowVector2< float > |
| |
| using | RowVector3f = RowVector3< float > |
| |
| using | RowVector4f = RowVector4< float > |
| |
| using | RowVector5f = RowVector5< float > |
| |
| using | RowVector6f = RowVector6< float > |
| |
| using | RowVector0d = RowVector0< double > |
| |
| using | RowVector1d = RowVector1< double > |
| |
| using | RowVector2d = RowVector2< double > |
| |
| using | RowVector3d = RowVector3< double > |
| |
| using | RowVector4d = RowVector4< double > |
| |
| using | RowVector5d = RowVector5< double > |
| |
| using | RowVector6d = RowVector6< double > |
| |
| using | RowVector0b = RowVector0< std::uint8_t > |
| |
| using | RowVector1b = RowVector1< std::uint8_t > |
| |
| using | RowVector2b = RowVector2< std::uint8_t > |
| |
| using | RowVector3b = RowVector3< std::uint8_t > |
| |
| using | RowVector4b = RowVector4< std::uint8_t > |
| |
| using | RowVector5b = RowVector5< std::uint8_t > |
| |
| using | RowVector6b = RowVector6< std::uint8_t > |
| |
| using | RowVector0s = RowVector0< std::uint16_t > |
| |
| using | RowVector1s = RowVector1< std::uint16_t > |
| |
| using | RowVector2s = RowVector2< std::uint16_t > |
| |
| using | RowVector3s = RowVector3< std::uint16_t > |
| |
| using | RowVector4s = RowVector4< std::uint16_t > |
| |
| using | RowVector5s = RowVector5< std::uint16_t > |
| |
| using | RowVector6s = RowVector6< std::uint16_t > |
| |
| using | RowVector0u = RowVector0< std::uint32_t > |
| |
| using | RowVector1u = RowVector1< std::uint32_t > |
| |
| using | RowVector2u = RowVector2< std::uint32_t > |
| |
| using | RowVector3u = RowVector3< std::uint32_t > |
| |
| using | RowVector4u = RowVector4< std::uint32_t > |
| |
| using | RowVector5u = RowVector5< std::uint32_t > |
| |
| using | RowVector6u = RowVector6< std::uint32_t > |
| |
| using | RowVector0i = RowVector0< std::int32_t > |
| |
| using | RowVector1i = RowVector1< std::int32_t > |
| |
| using | RowVector2i = RowVector2< std::int32_t > |
| |
| using | RowVector3i = RowVector3< std::int32_t > |
| |
| using | RowVector4i = RowVector4< std::int32_t > |
| |
| using | RowVector5i = RowVector5< std::int32_t > |
| |
| using | RowVector6i = RowVector6< std::int32_t > |
| |
| template<typename T > |
| using | AngleAxis = Eigen::AngleAxis< T > |
| |
| using | AngleAxisf = AngleAxis< float > |
| |
| using | AngleAxisd = AngleAxis< double > |
| |
| template<typename T > |
| using | Quaternion = Eigen::Quaternion< T > |
| |
| using | Quaternionf = Quaternion< float > |
| |
| using | Quaterniond = Quaternion< double > |
| |
| template<typename T > |
| using | Translation3 = Eigen::Translation< T, 3 > |
| |
| using | Translation3f = Translation3< float > |
| |
| using | Translation3d = Translation3< double > |
| |
| template<typename T > |
| using | Isometry3 = Eigen::Transform< T, 3, Eigen::Isometry > |
| |
| using | Isometry3f = Isometry3< float > |
| |
| using | Isometry3d = Isometry3< double > |
| |
| template<typename T > |
| using | Affine3 = Eigen::Transform< T, 3, Eigen::Affine > |
| |
| using | Affine3f = Affine3< float > |
| |
| using | Affine3d = Affine3< double > |
| |
| using | TransformationList = std::vector< Affine3f > |
| |
| template<typename T > |
| using | TransformationListT = std::vector< Affine3< T > > |
| |
| using | VertexArray = Matrix3Xf |
| |
| using | NormalArray = Matrix3Xf |
| |
| using | TriangleArray = Matrix3Xi |
| |
| using | ColorArray = Matrix3Xb |
| |
| using | ParameterSet = std::bitset< kMaxModelParams > |
| |
| using | SolverOptions_p = ::std::shared_ptr< SolverOptions > |
| |
| using | SolverOptions_u = ::std::unique_ptr< SolverOptions > |
| |
| using | SolverOptions_w = ::std::weak_ptr< SolverOptions > |
| |
| using | SolverOptions_const_p = ::std::shared_ptr< const SolverOptions > |
| |
| using | SolverOptions_const_u = ::std::unique_ptr< const SolverOptions > |
| |
| using | SolverOptions_const_w = ::std::weak_ptr< const SolverOptions > |
| |
| using | GaussNewtonSolverOptions_p = ::std::shared_ptr< GaussNewtonSolverOptions > |
| |
| using | GaussNewtonSolverOptions_u = ::std::unique_ptr< GaussNewtonSolverOptions > |
| |
| using | GaussNewtonSolverOptions_w = ::std::weak_ptr< GaussNewtonSolverOptions > |
| |
| using | GaussNewtonSolverOptions_const_p = ::std::shared_ptr< const GaussNewtonSolverOptions > |
| |
| using | GaussNewtonSolverOptions_const_u = ::std::unique_ptr< const GaussNewtonSolverOptions > |
| |
| using | GaussNewtonSolverOptions_const_w = ::std::weak_ptr< const GaussNewtonSolverOptions > |
| |
| using | Solver = SolverT< float > |
| |
| using | Solverd = SolverT< double > |
| |
| using | Solver_p = ::std::shared_ptr< Solver > |
| |
| using | Solver_u = ::std::unique_ptr< Solver > |
| |
| using | Solver_w = ::std::weak_ptr< Solver > |
| |
| using | Solver_const_p = ::std::shared_ptr< const Solver > |
| |
| using | Solver_const_u = ::std::unique_ptr< const Solver > |
| |
| using | Solver_const_w = ::std::weak_ptr< const Solver > |
| |
| using | Solverd_p = ::std::shared_ptr< Solverd > |
| |
| using | Solverd_u = ::std::unique_ptr< Solverd > |
| |
| using | Solverd_w = ::std::weak_ptr< Solverd > |
| |
| using | Solverd_const_p = ::std::shared_ptr< const Solverd > |
| |
| using | Solverd_const_u = ::std::unique_ptr< const Solverd > |
| |
| using | Solverd_const_w = ::std::weak_ptr< const Solverd > |
| |
| using | SolverFunction = SolverFunctionT< float > |
| |
| using | SolverFunctiond = SolverFunctionT< double > |
| |
| using | SolverFunction_p = ::std::shared_ptr< SolverFunction > |
| |
| using | SolverFunction_u = ::std::unique_ptr< SolverFunction > |
| |
| using | SolverFunction_w = ::std::weak_ptr< SolverFunction > |
| |
| using | SolverFunction_const_p = ::std::shared_ptr< const SolverFunction > |
| |
| using | SolverFunction_const_u = ::std::unique_ptr< const SolverFunction > |
| |
| using | SolverFunction_const_w = ::std::weak_ptr< const SolverFunction > |
| |
| using | SolverFunctiond_p = ::std::shared_ptr< SolverFunctiond > |
| |
| using | SolverFunctiond_u = ::std::unique_ptr< SolverFunctiond > |
| |
| using | SolverFunctiond_w = ::std::weak_ptr< SolverFunctiond > |
| |
| using | SolverFunctiond_const_p = ::std::shared_ptr< const SolverFunctiond > |
| |
| using | SolverFunctiond_const_u = ::std::unique_ptr< const SolverFunctiond > |
| |
| using | SolverFunctiond_const_w = ::std::weak_ptr< const SolverFunctiond > |
| |
| using | GaussNewtonSolver = GaussNewtonSolverT< float > |
| |
| using | GaussNewtonSolverd = GaussNewtonSolverT< double > |
| |
| using | GaussNewtonSolver_p = ::std::shared_ptr< GaussNewtonSolver > |
| |
| using | GaussNewtonSolver_u = ::std::unique_ptr< GaussNewtonSolver > |
| |
| using | GaussNewtonSolver_w = ::std::weak_ptr< GaussNewtonSolver > |
| |
| using | GaussNewtonSolver_const_p = ::std::shared_ptr< const GaussNewtonSolver > |
| |
| using | GaussNewtonSolver_const_u = ::std::unique_ptr< const GaussNewtonSolver > |
| |
| using | GaussNewtonSolver_const_w = ::std::weak_ptr< const GaussNewtonSolver > |
| |
| using | GaussNewtonSolverd_p = ::std::shared_ptr< GaussNewtonSolverd > |
| |
| using | GaussNewtonSolverd_u = ::std::unique_ptr< GaussNewtonSolverd > |
| |
| using | GaussNewtonSolverd_w = ::std::weak_ptr< GaussNewtonSolverd > |
| |
| using | GaussNewtonSolverd_const_p = ::std::shared_ptr< const GaussNewtonSolverd > |
| |
| using | GaussNewtonSolverd_const_u = ::std::unique_ptr< const GaussNewtonSolverd > |
| |
| using | GaussNewtonSolverd_const_w = ::std::weak_ptr< const GaussNewtonSolverd > |
| |
| using | GradientDescentSolver = GradientDescentSolverT< float > |
| |
| using | GradientDescentSolverd = GradientDescentSolverT< double > |
| |
| using | GradientDescentSolver_p = ::std::shared_ptr< GradientDescentSolver > |
| |
| using | GradientDescentSolver_u = ::std::unique_ptr< GradientDescentSolver > |
| |
| using | GradientDescentSolver_w = ::std::weak_ptr< GradientDescentSolver > |
| |
| using | GradientDescentSolver_const_p = ::std::shared_ptr< const GradientDescentSolver > |
| |
| using | GradientDescentSolver_const_u = ::std::unique_ptr< const GradientDescentSolver > |
| |
| using | GradientDescentSolver_const_w = ::std::weak_ptr< const GradientDescentSolver > |
| |
| using | GradientDescentSolverd_p = ::std::shared_ptr< GradientDescentSolverd > |
| |
| using | GradientDescentSolverd_u = ::std::unique_ptr< GradientDescentSolverd > |
| |
| using | GradientDescentSolverd_w = ::std::weak_ptr< GradientDescentSolverd > |
| |
| using | GradientDescentSolverd_const_p = ::std::shared_ptr< const GradientDescentSolverd > |
| |
| using | GradientDescentSolverd_const_u = ::std::unique_ptr< const GradientDescentSolverd > |
| |
| using | GradientDescentSolverd_const_w = ::std::weak_ptr< const GradientDescentSolverd > |
| |
| using | SubsetGaussNewtonSolver = SubsetGaussNewtonSolverT< float > |
| |
| using | SubsetGaussNewtonSolverd = SubsetGaussNewtonSolverT< double > |
| |
| using | SubsetGaussNewtonSolver_p = ::std::shared_ptr< SubsetGaussNewtonSolver > |
| |
| using | SubsetGaussNewtonSolver_u = ::std::unique_ptr< SubsetGaussNewtonSolver > |
| |
| using | SubsetGaussNewtonSolver_w = ::std::weak_ptr< SubsetGaussNewtonSolver > |
| |
| using | SubsetGaussNewtonSolver_const_p = ::std::shared_ptr< const SubsetGaussNewtonSolver > |
| |
| using | SubsetGaussNewtonSolver_const_u = ::std::unique_ptr< const SubsetGaussNewtonSolver > |
| |
| using | SubsetGaussNewtonSolver_const_w = ::std::weak_ptr< const SubsetGaussNewtonSolver > |
| |
| using | SubsetGaussNewtonSolverd_p = ::std::shared_ptr< SubsetGaussNewtonSolverd > |
| |
| using | SubsetGaussNewtonSolverd_u = ::std::unique_ptr< SubsetGaussNewtonSolverd > |
| |
| using | SubsetGaussNewtonSolverd_w = ::std::weak_ptr< SubsetGaussNewtonSolverd > |
| |
| using | SubsetGaussNewtonSolverd_const_p = ::std::shared_ptr< const SubsetGaussNewtonSolverd > |
| |
| using | SubsetGaussNewtonSolverd_const_u = ::std::unique_ptr< const SubsetGaussNewtonSolverd > |
| |
| using | SubsetGaussNewtonSolverd_const_w = ::std::weak_ptr< const SubsetGaussNewtonSolverd > |
| |
| template<typename S > |
| using | CollisionGeometryT = std::vector< TaperedCapsuleT< S > > |
| | Collection of tapered capsules representing a character's collision geometry.
|
| |
| using | CollisionGeometry = CollisionGeometryT< float > |
| |
| using | CollisionGeometryd = CollisionGeometryT< double > |
| |
| using | BlendShape_p = ::std::shared_ptr< BlendShape > |
| |
| using | BlendShape_u = ::std::unique_ptr< BlendShape > |
| |
| using | BlendShape_w = ::std::weak_ptr< BlendShape > |
| |
| using | BlendShape_const_p = ::std::shared_ptr< const BlendShape > |
| |
| using | BlendShape_const_u = ::std::unique_ptr< const BlendShape > |
| |
| using | BlendShape_const_w = ::std::weak_ptr< const BlendShape > |
| |
| using | BlendShapeBase_p = ::std::shared_ptr< BlendShapeBase > |
| |
| using | BlendShapeBase_u = ::std::unique_ptr< BlendShapeBase > |
| |
| using | BlendShapeBase_w = ::std::weak_ptr< BlendShapeBase > |
| |
| using | BlendShapeBase_const_p = ::std::shared_ptr< const BlendShapeBase > |
| |
| using | BlendShapeBase_const_u = ::std::unique_ptr< const BlendShapeBase > |
| |
| using | BlendShapeBase_const_w = ::std::weak_ptr< const BlendShapeBase > |
| |
| using | Locator_p = ::std::shared_ptr< Locator > |
| |
| using | Locator_u = ::std::unique_ptr< Locator > |
| |
| using | Locator_w = ::std::weak_ptr< Locator > |
| |
| using | Locator_const_p = ::std::shared_ptr< const Locator > |
| |
| using | Locator_const_u = ::std::unique_ptr< const Locator > |
| |
| using | Locator_const_w = ::std::weak_ptr< const Locator > |
| |
| using | PoseShape_p = ::std::shared_ptr< PoseShape > |
| |
| using | PoseShape_u = ::std::unique_ptr< PoseShape > |
| |
| using | PoseShape_w = ::std::weak_ptr< PoseShape > |
| |
| using | PoseShape_const_p = ::std::shared_ptr< const PoseShape > |
| |
| using | PoseShape_const_u = ::std::unique_ptr< const PoseShape > |
| |
| using | PoseShape_const_w = ::std::weak_ptr< const PoseShape > |
| |
| using | SkinWeights_p = ::std::shared_ptr< SkinWeights > |
| |
| using | SkinWeights_u = ::std::unique_ptr< SkinWeights > |
| |
| using | SkinWeights_w = ::std::weak_ptr< SkinWeights > |
| |
| using | SkinWeights_const_p = ::std::shared_ptr< const SkinWeights > |
| |
| using | SkinWeights_const_u = ::std::unique_ptr< const SkinWeights > |
| |
| using | SkinWeights_const_w = ::std::weak_ptr< const SkinWeights > |
| |
| using | SkinnedLocator_p = ::std::shared_ptr< SkinnedLocator > |
| |
| using | SkinnedLocator_u = ::std::unique_ptr< SkinnedLocator > |
| |
| using | SkinnedLocator_w = ::std::weak_ptr< SkinnedLocator > |
| |
| using | SkinnedLocator_const_p = ::std::shared_ptr< const SkinnedLocator > |
| |
| using | SkinnedLocator_const_u = ::std::unique_ptr< const SkinnedLocator > |
| |
| using | SkinnedLocator_const_w = ::std::weak_ptr< const SkinnedLocator > |
| |
| using | Character = CharacterT< float > |
| |
| using | Characterd = CharacterT< double > |
| |
| using | Character_p = ::std::shared_ptr< Character > |
| |
| using | Character_u = ::std::unique_ptr< Character > |
| |
| using | Character_w = ::std::weak_ptr< Character > |
| |
| using | Character_const_p = ::std::shared_ptr< const Character > |
| |
| using | Character_const_u = ::std::unique_ptr< const Character > |
| |
| using | Character_const_w = ::std::weak_ptr< const Character > |
| |
| using | Characterd_p = ::std::shared_ptr< Characterd > |
| |
| using | Characterd_u = ::std::unique_ptr< Characterd > |
| |
| using | Characterd_w = ::std::weak_ptr< Characterd > |
| |
| using | Characterd_const_p = ::std::shared_ptr< const Characterd > |
| |
| using | Characterd_const_u = ::std::unique_ptr< const Characterd > |
| |
| using | Characterd_const_w = ::std::weak_ptr< const Characterd > |
| |
| using | CharacterState = CharacterStateT< float > |
| |
| using | CharacterStated = CharacterStateT< double > |
| |
| using | CharacterState_p = ::std::shared_ptr< CharacterState > |
| |
| using | CharacterState_u = ::std::unique_ptr< CharacterState > |
| |
| using | CharacterState_w = ::std::weak_ptr< CharacterState > |
| |
| using | CharacterState_const_p = ::std::shared_ptr< const CharacterState > |
| |
| using | CharacterState_const_u = ::std::unique_ptr< const CharacterState > |
| |
| using | CharacterState_const_w = ::std::weak_ptr< const CharacterState > |
| |
| using | CharacterStated_p = ::std::shared_ptr< CharacterStated > |
| |
| using | CharacterStated_u = ::std::unique_ptr< CharacterStated > |
| |
| using | CharacterStated_w = ::std::weak_ptr< CharacterStated > |
| |
| using | CharacterStated_const_p = ::std::shared_ptr< const CharacterStated > |
| |
| using | CharacterStated_const_u = ::std::unique_ptr< const CharacterStated > |
| |
| using | CharacterStated_const_w = ::std::weak_ptr< const CharacterStated > |
| |
| using | CollisionGeometryState = CollisionGeometryStateT< float > |
| |
| using | CollisionGeometryStated = CollisionGeometryStateT< double > |
| |
| using | CollisionGeometryState_p = ::std::shared_ptr< CollisionGeometryState > |
| |
| using | CollisionGeometryState_u = ::std::unique_ptr< CollisionGeometryState > |
| |
| using | CollisionGeometryState_w = ::std::weak_ptr< CollisionGeometryState > |
| |
| using | CollisionGeometryState_const_p = ::std::shared_ptr< const CollisionGeometryState > |
| |
| using | CollisionGeometryState_const_u = ::std::unique_ptr< const CollisionGeometryState > |
| |
| using | CollisionGeometryState_const_w = ::std::weak_ptr< const CollisionGeometryState > |
| |
| using | CollisionGeometryStated_p = ::std::shared_ptr< CollisionGeometryStated > |
| |
| using | CollisionGeometryStated_u = ::std::unique_ptr< CollisionGeometryStated > |
| |
| using | CollisionGeometryStated_w = ::std::weak_ptr< CollisionGeometryStated > |
| |
| using | CollisionGeometryStated_const_p = ::std::shared_ptr< const CollisionGeometryStated > |
| |
| using | CollisionGeometryStated_const_u = ::std::unique_ptr< const CollisionGeometryStated > |
| |
| using | CollisionGeometryStated_const_w = ::std::weak_ptr< const CollisionGeometryStated > |
| |
| using | Joint = JointT< float > |
| |
| using | Jointd = JointT< double > |
| |
| using | Joint_p = ::std::shared_ptr< Joint > |
| |
| using | Joint_u = ::std::unique_ptr< Joint > |
| |
| using | Joint_w = ::std::weak_ptr< Joint > |
| |
| using | Joint_const_p = ::std::shared_ptr< const Joint > |
| |
| using | Joint_const_u = ::std::unique_ptr< const Joint > |
| |
| using | Joint_const_w = ::std::weak_ptr< const Joint > |
| |
| using | Jointd_p = ::std::shared_ptr< Jointd > |
| |
| using | Jointd_u = ::std::unique_ptr< Jointd > |
| |
| using | Jointd_w = ::std::weak_ptr< Jointd > |
| |
| using | Jointd_const_p = ::std::shared_ptr< const Jointd > |
| |
| using | Jointd_const_u = ::std::unique_ptr< const Jointd > |
| |
| using | Jointd_const_w = ::std::weak_ptr< const Jointd > |
| |
| using | JointState = JointStateT< float > |
| |
| using | JointStated = JointStateT< double > |
| |
| using | JointState_p = ::std::shared_ptr< JointState > |
| |
| using | JointState_u = ::std::unique_ptr< JointState > |
| |
| using | JointState_w = ::std::weak_ptr< JointState > |
| |
| using | JointState_const_p = ::std::shared_ptr< const JointState > |
| |
| using | JointState_const_u = ::std::unique_ptr< const JointState > |
| |
| using | JointState_const_w = ::std::weak_ptr< const JointState > |
| |
| using | JointStated_p = ::std::shared_ptr< JointStated > |
| |
| using | JointStated_u = ::std::unique_ptr< JointStated > |
| |
| using | JointStated_w = ::std::weak_ptr< JointStated > |
| |
| using | JointStated_const_p = ::std::shared_ptr< const JointStated > |
| |
| using | JointStated_const_u = ::std::unique_ptr< const JointStated > |
| |
| using | JointStated_const_w = ::std::weak_ptr< const JointStated > |
| |
| using | ParameterTransform = ParameterTransformT< float > |
| |
| using | ParameterTransformd = ParameterTransformT< double > |
| |
| using | ParameterTransform_p = ::std::shared_ptr< ParameterTransform > |
| |
| using | ParameterTransform_u = ::std::unique_ptr< ParameterTransform > |
| |
| using | ParameterTransform_w = ::std::weak_ptr< ParameterTransform > |
| |
| using | ParameterTransform_const_p = ::std::shared_ptr< const ParameterTransform > |
| |
| using | ParameterTransform_const_u = ::std::unique_ptr< const ParameterTransform > |
| |
| using | ParameterTransform_const_w = ::std::weak_ptr< const ParameterTransform > |
| |
| using | ParameterTransformd_p = ::std::shared_ptr< ParameterTransformd > |
| |
| using | ParameterTransformd_u = ::std::unique_ptr< ParameterTransformd > |
| |
| using | ParameterTransformd_w = ::std::weak_ptr< ParameterTransformd > |
| |
| using | ParameterTransformd_const_p = ::std::shared_ptr< const ParameterTransformd > |
| |
| using | ParameterTransformd_const_u = ::std::unique_ptr< const ParameterTransformd > |
| |
| using | ParameterTransformd_const_w = ::std::weak_ptr< const ParameterTransformd > |
| |
| using | Skeleton = SkeletonT< float > |
| |
| using | Skeletond = SkeletonT< double > |
| |
| using | Skeleton_p = ::std::shared_ptr< Skeleton > |
| |
| using | Skeleton_u = ::std::unique_ptr< Skeleton > |
| |
| using | Skeleton_w = ::std::weak_ptr< Skeleton > |
| |
| using | Skeleton_const_p = ::std::shared_ptr< const Skeleton > |
| |
| using | Skeleton_const_u = ::std::unique_ptr< const Skeleton > |
| |
| using | Skeleton_const_w = ::std::weak_ptr< const Skeleton > |
| |
| using | Skeletond_p = ::std::shared_ptr< Skeletond > |
| |
| using | Skeletond_u = ::std::unique_ptr< Skeletond > |
| |
| using | Skeletond_w = ::std::weak_ptr< Skeletond > |
| |
| using | Skeletond_const_p = ::std::shared_ptr< const Skeletond > |
| |
| using | Skeletond_const_u = ::std::unique_ptr< const Skeletond > |
| |
| using | Skeletond_const_w = ::std::weak_ptr< const Skeletond > |
| |
| using | SkeletonState = SkeletonStateT< float > |
| |
| using | SkeletonStated = SkeletonStateT< double > |
| |
| using | SkeletonState_p = ::std::shared_ptr< SkeletonState > |
| |
| using | SkeletonState_u = ::std::unique_ptr< SkeletonState > |
| |
| using | SkeletonState_w = ::std::weak_ptr< SkeletonState > |
| |
| using | SkeletonState_const_p = ::std::shared_ptr< const SkeletonState > |
| |
| using | SkeletonState_const_u = ::std::unique_ptr< const SkeletonState > |
| |
| using | SkeletonState_const_w = ::std::weak_ptr< const SkeletonState > |
| |
| using | SkeletonStated_p = ::std::shared_ptr< SkeletonStated > |
| |
| using | SkeletonStated_u = ::std::unique_ptr< SkeletonStated > |
| |
| using | SkeletonStated_w = ::std::weak_ptr< SkeletonStated > |
| |
| using | SkeletonStated_const_p = ::std::shared_ptr< const SkeletonStated > |
| |
| using | SkeletonStated_const_u = ::std::unique_ptr< const SkeletonStated > |
| |
| using | SkeletonStated_const_w = ::std::weak_ptr< const SkeletonStated > |
| |
| using | MeshState = MeshStateT< float > |
| |
| using | MeshStated = MeshStateT< double > |
| |
| using | MeshState_p = ::std::shared_ptr< MeshState > |
| |
| using | MeshState_u = ::std::unique_ptr< MeshState > |
| |
| using | MeshState_w = ::std::weak_ptr< MeshState > |
| |
| using | MeshState_const_p = ::std::shared_ptr< const MeshState > |
| |
| using | MeshState_const_u = ::std::unique_ptr< const MeshState > |
| |
| using | MeshState_const_w = ::std::weak_ptr< const MeshState > |
| |
| using | MeshStated_p = ::std::shared_ptr< MeshStated > |
| |
| using | MeshStated_u = ::std::unique_ptr< MeshStated > |
| |
| using | MeshStated_w = ::std::weak_ptr< MeshStated > |
| |
| using | MeshStated_const_p = ::std::shared_ptr< const MeshStated > |
| |
| using | MeshStated_const_u = ::std::unique_ptr< const MeshStated > |
| |
| using | MeshStated_const_w = ::std::weak_ptr< const MeshStated > |
| |
| using | TaperedCapsule = TaperedCapsuleT< float > |
| |
| using | TaperedCapsuled = TaperedCapsuleT< double > |
| |
| using | TaperedCapsule_p = ::std::shared_ptr< TaperedCapsule > |
| |
| using | TaperedCapsule_u = ::std::unique_ptr< TaperedCapsule > |
| |
| using | TaperedCapsule_w = ::std::weak_ptr< TaperedCapsule > |
| |
| using | TaperedCapsule_const_p = ::std::shared_ptr< const TaperedCapsule > |
| |
| using | TaperedCapsule_const_u = ::std::unique_ptr< const TaperedCapsule > |
| |
| using | TaperedCapsule_const_w = ::std::weak_ptr< const TaperedCapsule > |
| |
| using | TaperedCapsuled_p = ::std::shared_ptr< TaperedCapsuled > |
| |
| using | TaperedCapsuled_u = ::std::unique_ptr< TaperedCapsuled > |
| |
| using | TaperedCapsuled_w = ::std::weak_ptr< TaperedCapsuled > |
| |
| using | TaperedCapsuled_const_p = ::std::shared_ptr< const TaperedCapsuled > |
| |
| using | TaperedCapsuled_const_u = ::std::unique_ptr< const TaperedCapsuled > |
| |
| using | TaperedCapsuled_const_w = ::std::weak_ptr< const TaperedCapsuled > |
| |
| using | InverseParameterTransform = InverseParameterTransformT< float > |
| |
| using | InverseParameterTransformd = InverseParameterTransformT< double > |
| |
| template<typename T > |
| using | JointListT = std::vector< JointT< T > > |
| | A list of joints (e.g., of a skeleton).
|
| |
| using | JointList = JointListT< float > |
| |
| using | JointListd = JointListT< double > |
| |
| template<typename T > |
| using | JointStateListT = std::vector< JointStateT< T > > |
| | Structure describing the state of all joints in a skeleton.
|
| |
| using | JointStateList = JointStateListT< float > |
| |
| using | LocatorList = std::vector< Locator > |
| | A collection of locators attached to a skeleton.
|
| |
| using | ParameterLimits = std::vector< ParameterLimit > |
| |
| using | ParameterSets = std::unordered_map< std::string, ParameterSet > |
| |
| using | PoseConstraints = std::unordered_map< std::string, PoseConstraint > |
| |
| using | IndexMatrix = Eigen::Matrix< uint32_t, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign|Eigen::RowMajor > |
| | Matrix type for storing joint indices that influence each vertex.
|
| |
| using | WeightMatrix = Eigen::Matrix< float, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign|Eigen::RowMajor > |
| | Matrix type for storing weights of joint influences on each vertex.
|
| |
| using | SkinnedLocatorList = std::vector< SkinnedLocator > |
| | A collection of locators attached to a skeleton.
|
| |
| template<typename T > |
| using | JointVectorT = Eigen::Matrix< T, kParametersPerJoint, 1 > |
| |
| using | JointVector = JointVectorT< float > |
| |
| using | ModelParameters = ModelParametersT< float > |
| |
| using | ModelParametersd = ModelParametersT< double > |
| |
| using | BlendWeights = BlendWeightsT< float > |
| |
| using | BlendWeightsd = BlendWeightsT< double > |
| |
| using | JointParameters = JointParametersT< float > |
| |
| using | JointParametersd = JointParametersT< double > |
| |
| using | JointStateListd = JointStateListT< double > |
| |
| using | CharacterParameters = CharacterParametersT< float > |
| |
| using | CharacterParametersd = CharacterParametersT< double > |
| |
| using | MotionParameters = std::tuple< std::vector< std::string >, Eigen::MatrixXf > |
| |
| using | IdentityParameters = std::tuple< std::vector< std::string >, Eigen::VectorXf > |
| |
| using | ConstraintDataList = std::vector< ConstraintData > |
| | A list of ConstraintData.
|
| |
| template<typename T > |
| using | optional_ref = std::optional< std::reference_wrapper< T > > |
| | An optional of a reference.
|
| |
| using | ConstraintData_p = ::std::shared_ptr< ConstraintData > |
| |
| using | ConstraintData_u = ::std::unique_ptr< ConstraintData > |
| |
| using | ConstraintData_w = ::std::weak_ptr< ConstraintData > |
| |
| using | ConstraintData_const_p = ::std::shared_ptr< const ConstraintData > |
| |
| using | ConstraintData_const_u = ::std::unique_ptr< const ConstraintData > |
| |
| using | ConstraintData_const_w = ::std::weak_ptr< const ConstraintData > |
| |
| using | GaussNewtonSolverQROptions_p = ::std::shared_ptr< GaussNewtonSolverQROptions > |
| |
| using | GaussNewtonSolverQROptions_u = ::std::unique_ptr< GaussNewtonSolverQROptions > |
| |
| using | GaussNewtonSolverQROptions_w = ::std::weak_ptr< GaussNewtonSolverQROptions > |
| |
| using | GaussNewtonSolverQROptions_const_p = ::std::shared_ptr< const GaussNewtonSolverQROptions > |
| |
| using | GaussNewtonSolverQROptions_const_u = ::std::unique_ptr< const GaussNewtonSolverQROptions > |
| |
| using | GaussNewtonSolverQROptions_const_w = ::std::weak_ptr< const GaussNewtonSolverQROptions > |
| |
| using | SimdNormalConstraints_p = ::std::shared_ptr< SimdNormalConstraints > |
| |
| using | SimdNormalConstraints_u = ::std::unique_ptr< SimdNormalConstraints > |
| |
| using | SimdNormalConstraints_w = ::std::weak_ptr< SimdNormalConstraints > |
| |
| using | SimdNormalConstraints_const_p = ::std::shared_ptr< const SimdNormalConstraints > |
| |
| using | SimdNormalConstraints_const_u = ::std::unique_ptr< const SimdNormalConstraints > |
| |
| using | SimdNormalConstraints_const_w = ::std::weak_ptr< const SimdNormalConstraints > |
| |
| using | SimdPlaneConstraints_p = ::std::shared_ptr< SimdPlaneConstraints > |
| |
| using | SimdPlaneConstraints_u = ::std::unique_ptr< SimdPlaneConstraints > |
| |
| using | SimdPlaneConstraints_w = ::std::weak_ptr< SimdPlaneConstraints > |
| |
| using | SimdPlaneConstraints_const_p = ::std::shared_ptr< const SimdPlaneConstraints > |
| |
| using | SimdPlaneConstraints_const_u = ::std::unique_ptr< const SimdPlaneConstraints > |
| |
| using | SimdPlaneConstraints_const_w = ::std::weak_ptr< const SimdPlaneConstraints > |
| |
| using | SimdPositionConstraints_p = ::std::shared_ptr< SimdPositionConstraints > |
| |
| using | SimdPositionConstraints_u = ::std::unique_ptr< SimdPositionConstraints > |
| |
| using | SimdPositionConstraints_w = ::std::weak_ptr< SimdPositionConstraints > |
| |
| using | SimdPositionConstraints_const_p = ::std::shared_ptr< const SimdPositionConstraints > |
| |
| using | SimdPositionConstraints_const_u = ::std::unique_ptr< const SimdPositionConstraints > |
| |
| using | SimdPositionConstraints_const_w = ::std::weak_ptr< const SimdPositionConstraints > |
| |
| using | AimData = AimDataT< float > |
| |
| using | AimDatad = AimDataT< double > |
| |
| using | AimData_p = ::std::shared_ptr< AimData > |
| |
| using | AimData_u = ::std::unique_ptr< AimData > |
| |
| using | AimData_w = ::std::weak_ptr< AimData > |
| |
| using | AimData_const_p = ::std::shared_ptr< const AimData > |
| |
| using | AimData_const_u = ::std::unique_ptr< const AimData > |
| |
| using | AimData_const_w = ::std::weak_ptr< const AimData > |
| |
| using | AimDatad_p = ::std::shared_ptr< AimDatad > |
| |
| using | AimDatad_u = ::std::unique_ptr< AimDatad > |
| |
| using | AimDatad_w = ::std::weak_ptr< AimDatad > |
| |
| using | AimDatad_const_p = ::std::shared_ptr< const AimDatad > |
| |
| using | AimDatad_const_u = ::std::unique_ptr< const AimDatad > |
| |
| using | AimDatad_const_w = ::std::weak_ptr< const AimDatad > |
| |
| using | FixedAxisData = FixedAxisDataT< float > |
| |
| using | FixedAxisDatad = FixedAxisDataT< double > |
| |
| using | FixedAxisData_p = ::std::shared_ptr< FixedAxisData > |
| |
| using | FixedAxisData_u = ::std::unique_ptr< FixedAxisData > |
| |
| using | FixedAxisData_w = ::std::weak_ptr< FixedAxisData > |
| |
| using | FixedAxisData_const_p = ::std::shared_ptr< const FixedAxisData > |
| |
| using | FixedAxisData_const_u = ::std::unique_ptr< const FixedAxisData > |
| |
| using | FixedAxisData_const_w = ::std::weak_ptr< const FixedAxisData > |
| |
| using | FixedAxisDatad_p = ::std::shared_ptr< FixedAxisDatad > |
| |
| using | FixedAxisDatad_u = ::std::unique_ptr< FixedAxisDatad > |
| |
| using | FixedAxisDatad_w = ::std::weak_ptr< FixedAxisDatad > |
| |
| using | FixedAxisDatad_const_p = ::std::shared_ptr< const FixedAxisDatad > |
| |
| using | FixedAxisDatad_const_u = ::std::unique_ptr< const FixedAxisDatad > |
| |
| using | FixedAxisDatad_const_w = ::std::weak_ptr< const FixedAxisDatad > |
| |
| using | NormalData = NormalDataT< float > |
| |
| using | NormalDatad = NormalDataT< double > |
| |
| using | NormalData_p = ::std::shared_ptr< NormalData > |
| |
| using | NormalData_u = ::std::unique_ptr< NormalData > |
| |
| using | NormalData_w = ::std::weak_ptr< NormalData > |
| |
| using | NormalData_const_p = ::std::shared_ptr< const NormalData > |
| |
| using | NormalData_const_u = ::std::unique_ptr< const NormalData > |
| |
| using | NormalData_const_w = ::std::weak_ptr< const NormalData > |
| |
| using | NormalDatad_p = ::std::shared_ptr< NormalDatad > |
| |
| using | NormalDatad_u = ::std::unique_ptr< NormalDatad > |
| |
| using | NormalDatad_w = ::std::weak_ptr< NormalDatad > |
| |
| using | NormalDatad_const_p = ::std::shared_ptr< const NormalDatad > |
| |
| using | NormalDatad_const_u = ::std::unique_ptr< const NormalDatad > |
| |
| using | NormalDatad_const_w = ::std::weak_ptr< const NormalDatad > |
| |
| using | OrientationData = OrientationDataT< float > |
| |
| using | OrientationDatad = OrientationDataT< double > |
| |
| using | OrientationData_p = ::std::shared_ptr< OrientationData > |
| |
| using | OrientationData_u = ::std::unique_ptr< OrientationData > |
| |
| using | OrientationData_w = ::std::weak_ptr< OrientationData > |
| |
| using | OrientationData_const_p = ::std::shared_ptr< const OrientationData > |
| |
| using | OrientationData_const_u = ::std::unique_ptr< const OrientationData > |
| |
| using | OrientationData_const_w = ::std::weak_ptr< const OrientationData > |
| |
| using | OrientationDatad_p = ::std::shared_ptr< OrientationDatad > |
| |
| using | OrientationDatad_u = ::std::unique_ptr< OrientationDatad > |
| |
| using | OrientationDatad_w = ::std::weak_ptr< OrientationDatad > |
| |
| using | OrientationDatad_const_p = ::std::shared_ptr< const OrientationDatad > |
| |
| using | OrientationDatad_const_u = ::std::unique_ptr< const OrientationDatad > |
| |
| using | OrientationDatad_const_w = ::std::weak_ptr< const OrientationDatad > |
| |
| using | PointTriangleVertexConstraint = PointTriangleVertexConstraintT< float > |
| |
| using | PointTriangleVertexConstraintd = PointTriangleVertexConstraintT< double > |
| |
| using | PointTriangleVertexConstraint_p = ::std::shared_ptr< PointTriangleVertexConstraint > |
| |
| using | PointTriangleVertexConstraint_u = ::std::unique_ptr< PointTriangleVertexConstraint > |
| |
| using | PointTriangleVertexConstraint_w = ::std::weak_ptr< PointTriangleVertexConstraint > |
| |
| using | PointTriangleVertexConstraint_const_p = ::std::shared_ptr< const PointTriangleVertexConstraint > |
| |
| using | PointTriangleVertexConstraint_const_u = ::std::unique_ptr< const PointTriangleVertexConstraint > |
| |
| using | PointTriangleVertexConstraint_const_w = ::std::weak_ptr< const PointTriangleVertexConstraint > |
| |
| using | PointTriangleVertexConstraintd_p = ::std::shared_ptr< PointTriangleVertexConstraintd > |
| |
| using | PointTriangleVertexConstraintd_u = ::std::unique_ptr< PointTriangleVertexConstraintd > |
| |
| using | PointTriangleVertexConstraintd_w = ::std::weak_ptr< PointTriangleVertexConstraintd > |
| |
| using | PointTriangleVertexConstraintd_const_p = ::std::shared_ptr< const PointTriangleVertexConstraintd > |
| |
| using | PointTriangleVertexConstraintd_const_u = ::std::unique_ptr< const PointTriangleVertexConstraintd > |
| |
| using | PointTriangleVertexConstraintd_const_w = ::std::weak_ptr< const PointTriangleVertexConstraintd > |
| |
| using | PlaneData = PlaneDataT< float > |
| |
| using | PlaneDatad = PlaneDataT< double > |
| |
| using | PlaneData_p = ::std::shared_ptr< PlaneData > |
| |
| using | PlaneData_u = ::std::unique_ptr< PlaneData > |
| |
| using | PlaneData_w = ::std::weak_ptr< PlaneData > |
| |
| using | PlaneData_const_p = ::std::shared_ptr< const PlaneData > |
| |
| using | PlaneData_const_u = ::std::unique_ptr< const PlaneData > |
| |
| using | PlaneData_const_w = ::std::weak_ptr< const PlaneData > |
| |
| using | PlaneDatad_p = ::std::shared_ptr< PlaneDatad > |
| |
| using | PlaneDatad_u = ::std::unique_ptr< PlaneDatad > |
| |
| using | PlaneDatad_w = ::std::weak_ptr< PlaneDatad > |
| |
| using | PlaneDatad_const_p = ::std::shared_ptr< const PlaneDatad > |
| |
| using | PlaneDatad_const_u = ::std::unique_ptr< const PlaneDatad > |
| |
| using | PlaneDatad_const_w = ::std::weak_ptr< const PlaneDatad > |
| |
| using | PositionData = PositionDataT< float > |
| |
| using | PositionDatad = PositionDataT< double > |
| |
| using | PositionData_p = ::std::shared_ptr< PositionData > |
| |
| using | PositionData_u = ::std::unique_ptr< PositionData > |
| |
| using | PositionData_w = ::std::weak_ptr< PositionData > |
| |
| using | PositionData_const_p = ::std::shared_ptr< const PositionData > |
| |
| using | PositionData_const_u = ::std::unique_ptr< const PositionData > |
| |
| using | PositionData_const_w = ::std::weak_ptr< const PositionData > |
| |
| using | PositionDatad_p = ::std::shared_ptr< PositionDatad > |
| |
| using | PositionDatad_u = ::std::unique_ptr< PositionDatad > |
| |
| using | PositionDatad_w = ::std::weak_ptr< PositionDatad > |
| |
| using | PositionDatad_const_p = ::std::shared_ptr< const PositionDatad > |
| |
| using | PositionDatad_const_u = ::std::unique_ptr< const PositionDatad > |
| |
| using | PositionDatad_const_w = ::std::weak_ptr< const PositionDatad > |
| |
| using | SkinnedLocatorConstraint = SkinnedLocatorConstraintT< float > |
| |
| using | SkinnedLocatorConstraintd = SkinnedLocatorConstraintT< double > |
| |
| using | SkinnedLocatorConstraint_p = ::std::shared_ptr< SkinnedLocatorConstraint > |
| |
| using | SkinnedLocatorConstraint_u = ::std::unique_ptr< SkinnedLocatorConstraint > |
| |
| using | SkinnedLocatorConstraint_w = ::std::weak_ptr< SkinnedLocatorConstraint > |
| |
| using | SkinnedLocatorConstraint_const_p = ::std::shared_ptr< const SkinnedLocatorConstraint > |
| |
| using | SkinnedLocatorConstraint_const_u = ::std::unique_ptr< const SkinnedLocatorConstraint > |
| |
| using | SkinnedLocatorConstraint_const_w = ::std::weak_ptr< const SkinnedLocatorConstraint > |
| |
| using | SkinnedLocatorConstraintd_p = ::std::shared_ptr< SkinnedLocatorConstraintd > |
| |
| using | SkinnedLocatorConstraintd_u = ::std::unique_ptr< SkinnedLocatorConstraintd > |
| |
| using | SkinnedLocatorConstraintd_w = ::std::weak_ptr< SkinnedLocatorConstraintd > |
| |
| using | SkinnedLocatorConstraintd_const_p = ::std::shared_ptr< const SkinnedLocatorConstraintd > |
| |
| using | SkinnedLocatorConstraintd_const_u = ::std::unique_ptr< const SkinnedLocatorConstraintd > |
| |
| using | SkinnedLocatorConstraintd_const_w = ::std::weak_ptr< const SkinnedLocatorConstraintd > |
| |
| using | SkinnedLocatorTriangleConstraint = SkinnedLocatorTriangleConstraintT< float > |
| |
| using | SkinnedLocatorTriangleConstraintd = SkinnedLocatorTriangleConstraintT< double > |
| |
| using | SkinnedLocatorTriangleConstraint_p = ::std::shared_ptr< SkinnedLocatorTriangleConstraint > |
| |
| using | SkinnedLocatorTriangleConstraint_u = ::std::unique_ptr< SkinnedLocatorTriangleConstraint > |
| |
| using | SkinnedLocatorTriangleConstraint_w = ::std::weak_ptr< SkinnedLocatorTriangleConstraint > |
| |
| using | SkinnedLocatorTriangleConstraint_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleConstraint > |
| |
| using | SkinnedLocatorTriangleConstraint_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleConstraint > |
| |
| using | SkinnedLocatorTriangleConstraint_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleConstraint > |
| |
| using | SkinnedLocatorTriangleConstraintd_p = ::std::shared_ptr< SkinnedLocatorTriangleConstraintd > |
| |
| using | SkinnedLocatorTriangleConstraintd_u = ::std::unique_ptr< SkinnedLocatorTriangleConstraintd > |
| |
| using | SkinnedLocatorTriangleConstraintd_w = ::std::weak_ptr< SkinnedLocatorTriangleConstraintd > |
| |
| using | SkinnedLocatorTriangleConstraintd_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleConstraintd > |
| |
| using | SkinnedLocatorTriangleConstraintd_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleConstraintd > |
| |
| using | SkinnedLocatorTriangleConstraintd_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleConstraintd > |
| |
| using | VertexConstraint = VertexConstraintT< float > |
| |
| using | VertexConstraintd = VertexConstraintT< double > |
| |
| using | VertexConstraint_p = ::std::shared_ptr< VertexConstraint > |
| |
| using | VertexConstraint_u = ::std::unique_ptr< VertexConstraint > |
| |
| using | VertexConstraint_w = ::std::weak_ptr< VertexConstraint > |
| |
| using | VertexConstraint_const_p = ::std::shared_ptr< const VertexConstraint > |
| |
| using | VertexConstraint_const_u = ::std::unique_ptr< const VertexConstraint > |
| |
| using | VertexConstraint_const_w = ::std::weak_ptr< const VertexConstraint > |
| |
| using | VertexConstraintd_p = ::std::shared_ptr< VertexConstraintd > |
| |
| using | VertexConstraintd_u = ::std::unique_ptr< VertexConstraintd > |
| |
| using | VertexConstraintd_w = ::std::weak_ptr< VertexConstraintd > |
| |
| using | VertexConstraintd_const_p = ::std::shared_ptr< const VertexConstraintd > |
| |
| using | VertexConstraintd_const_u = ::std::unique_ptr< const VertexConstraintd > |
| |
| using | VertexConstraintd_const_w = ::std::weak_ptr< const VertexConstraintd > |
| |
| using | VertexProjectionConstraint = VertexProjectionConstraintT< float > |
| |
| using | VertexProjectionConstraintd = VertexProjectionConstraintT< double > |
| |
| using | VertexProjectionConstraint_p = ::std::shared_ptr< VertexProjectionConstraint > |
| |
| using | VertexProjectionConstraint_u = ::std::unique_ptr< VertexProjectionConstraint > |
| |
| using | VertexProjectionConstraint_w = ::std::weak_ptr< VertexProjectionConstraint > |
| |
| using | VertexProjectionConstraint_const_p = ::std::shared_ptr< const VertexProjectionConstraint > |
| |
| using | VertexProjectionConstraint_const_u = ::std::unique_ptr< const VertexProjectionConstraint > |
| |
| using | VertexProjectionConstraint_const_w = ::std::weak_ptr< const VertexProjectionConstraint > |
| |
| using | VertexProjectionConstraintd_p = ::std::shared_ptr< VertexProjectionConstraintd > |
| |
| using | VertexProjectionConstraintd_u = ::std::unique_ptr< VertexProjectionConstraintd > |
| |
| using | VertexProjectionConstraintd_w = ::std::weak_ptr< VertexProjectionConstraintd > |
| |
| using | VertexProjectionConstraintd_const_p = ::std::shared_ptr< const VertexProjectionConstraintd > |
| |
| using | VertexProjectionConstraintd_const_u = ::std::unique_ptr< const VertexProjectionConstraintd > |
| |
| using | VertexProjectionConstraintd_const_w = ::std::weak_ptr< const VertexProjectionConstraintd > |
| |
| using | SimdNormalErrorFunction_p = ::std::shared_ptr< SimdNormalErrorFunction > |
| |
| using | SimdNormalErrorFunction_u = ::std::unique_ptr< SimdNormalErrorFunction > |
| |
| using | SimdNormalErrorFunction_w = ::std::weak_ptr< SimdNormalErrorFunction > |
| |
| using | SimdNormalErrorFunction_const_p = ::std::shared_ptr< const SimdNormalErrorFunction > |
| |
| using | SimdNormalErrorFunction_const_u = ::std::unique_ptr< const SimdNormalErrorFunction > |
| |
| using | SimdNormalErrorFunction_const_w = ::std::weak_ptr< const SimdNormalErrorFunction > |
| |
| using | SimdPlaneErrorFunction_p = ::std::shared_ptr< SimdPlaneErrorFunction > |
| |
| using | SimdPlaneErrorFunction_u = ::std::unique_ptr< SimdPlaneErrorFunction > |
| |
| using | SimdPlaneErrorFunction_w = ::std::weak_ptr< SimdPlaneErrorFunction > |
| |
| using | SimdPlaneErrorFunction_const_p = ::std::shared_ptr< const SimdPlaneErrorFunction > |
| |
| using | SimdPlaneErrorFunction_const_u = ::std::unique_ptr< const SimdPlaneErrorFunction > |
| |
| using | SimdPlaneErrorFunction_const_w = ::std::weak_ptr< const SimdPlaneErrorFunction > |
| |
| using | SimdPositionErrorFunction_p = ::std::shared_ptr< SimdPositionErrorFunction > |
| |
| using | SimdPositionErrorFunction_u = ::std::unique_ptr< SimdPositionErrorFunction > |
| |
| using | SimdPositionErrorFunction_w = ::std::weak_ptr< SimdPositionErrorFunction > |
| |
| using | SimdPositionErrorFunction_const_p = ::std::shared_ptr< const SimdPositionErrorFunction > |
| |
| using | SimdPositionErrorFunction_const_u = ::std::unique_ptr< const SimdPositionErrorFunction > |
| |
| using | SimdPositionErrorFunction_const_w = ::std::weak_ptr< const SimdPositionErrorFunction > |
| |
| using | SimdNormalErrorFunctionAVX_p = ::std::shared_ptr< SimdNormalErrorFunctionAVX > |
| |
| using | SimdNormalErrorFunctionAVX_u = ::std::unique_ptr< SimdNormalErrorFunctionAVX > |
| |
| using | SimdNormalErrorFunctionAVX_w = ::std::weak_ptr< SimdNormalErrorFunctionAVX > |
| |
| using | SimdNormalErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdNormalErrorFunctionAVX > |
| |
| using | SimdNormalErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdNormalErrorFunctionAVX > |
| |
| using | SimdNormalErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdNormalErrorFunctionAVX > |
| |
| using | SimdPlaneErrorFunctionAVX_p = ::std::shared_ptr< SimdPlaneErrorFunctionAVX > |
| |
| using | SimdPlaneErrorFunctionAVX_u = ::std::unique_ptr< SimdPlaneErrorFunctionAVX > |
| |
| using | SimdPlaneErrorFunctionAVX_w = ::std::weak_ptr< SimdPlaneErrorFunctionAVX > |
| |
| using | SimdPlaneErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdPlaneErrorFunctionAVX > |
| |
| using | SimdPlaneErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdPlaneErrorFunctionAVX > |
| |
| using | SimdPlaneErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdPlaneErrorFunctionAVX > |
| |
| using | SimdPositionErrorFunctionAVX_p = ::std::shared_ptr< SimdPositionErrorFunctionAVX > |
| |
| using | SimdPositionErrorFunctionAVX_u = ::std::unique_ptr< SimdPositionErrorFunctionAVX > |
| |
| using | SimdPositionErrorFunctionAVX_w = ::std::weak_ptr< SimdPositionErrorFunctionAVX > |
| |
| using | SimdPositionErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdPositionErrorFunctionAVX > |
| |
| using | SimdPositionErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdPositionErrorFunctionAVX > |
| |
| using | SimdPositionErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdPositionErrorFunctionAVX > |
| |
| using | AimDirErrorFunction = AimDirErrorFunctionT< float > |
| |
| using | AimDirErrorFunctiond = AimDirErrorFunctionT< double > |
| |
| using | AimDirErrorFunction_p = ::std::shared_ptr< AimDirErrorFunction > |
| |
| using | AimDirErrorFunction_u = ::std::unique_ptr< AimDirErrorFunction > |
| |
| using | AimDirErrorFunction_w = ::std::weak_ptr< AimDirErrorFunction > |
| |
| using | AimDirErrorFunction_const_p = ::std::shared_ptr< const AimDirErrorFunction > |
| |
| using | AimDirErrorFunction_const_u = ::std::unique_ptr< const AimDirErrorFunction > |
| |
| using | AimDirErrorFunction_const_w = ::std::weak_ptr< const AimDirErrorFunction > |
| |
| using | AimDirErrorFunctiond_p = ::std::shared_ptr< AimDirErrorFunctiond > |
| |
| using | AimDirErrorFunctiond_u = ::std::unique_ptr< AimDirErrorFunctiond > |
| |
| using | AimDirErrorFunctiond_w = ::std::weak_ptr< AimDirErrorFunctiond > |
| |
| using | AimDirErrorFunctiond_const_p = ::std::shared_ptr< const AimDirErrorFunctiond > |
| |
| using | AimDirErrorFunctiond_const_u = ::std::unique_ptr< const AimDirErrorFunctiond > |
| |
| using | AimDirErrorFunctiond_const_w = ::std::weak_ptr< const AimDirErrorFunctiond > |
| |
| using | AimDistErrorFunction = AimDistErrorFunctionT< float > |
| |
| using | AimDistErrorFunctiond = AimDistErrorFunctionT< double > |
| |
| using | AimDistErrorFunction_p = ::std::shared_ptr< AimDistErrorFunction > |
| |
| using | AimDistErrorFunction_u = ::std::unique_ptr< AimDistErrorFunction > |
| |
| using | AimDistErrorFunction_w = ::std::weak_ptr< AimDistErrorFunction > |
| |
| using | AimDistErrorFunction_const_p = ::std::shared_ptr< const AimDistErrorFunction > |
| |
| using | AimDistErrorFunction_const_u = ::std::unique_ptr< const AimDistErrorFunction > |
| |
| using | AimDistErrorFunction_const_w = ::std::weak_ptr< const AimDistErrorFunction > |
| |
| using | AimDistErrorFunctiond_p = ::std::shared_ptr< AimDistErrorFunctiond > |
| |
| using | AimDistErrorFunctiond_u = ::std::unique_ptr< AimDistErrorFunctiond > |
| |
| using | AimDistErrorFunctiond_w = ::std::weak_ptr< AimDistErrorFunctiond > |
| |
| using | AimDistErrorFunctiond_const_p = ::std::shared_ptr< const AimDistErrorFunctiond > |
| |
| using | AimDistErrorFunctiond_const_u = ::std::unique_ptr< const AimDistErrorFunctiond > |
| |
| using | AimDistErrorFunctiond_const_w = ::std::weak_ptr< const AimDistErrorFunctiond > |
| |
| using | CollisionErrorFunction = CollisionErrorFunctionT< float > |
| |
| using | CollisionErrorFunctiond = CollisionErrorFunctionT< double > |
| |
| using | CollisionErrorFunction_p = ::std::shared_ptr< CollisionErrorFunction > |
| |
| using | CollisionErrorFunction_u = ::std::unique_ptr< CollisionErrorFunction > |
| |
| using | CollisionErrorFunction_w = ::std::weak_ptr< CollisionErrorFunction > |
| |
| using | CollisionErrorFunction_const_p = ::std::shared_ptr< const CollisionErrorFunction > |
| |
| using | CollisionErrorFunction_const_u = ::std::unique_ptr< const CollisionErrorFunction > |
| |
| using | CollisionErrorFunction_const_w = ::std::weak_ptr< const CollisionErrorFunction > |
| |
| using | CollisionErrorFunctiond_p = ::std::shared_ptr< CollisionErrorFunctiond > |
| |
| using | CollisionErrorFunctiond_u = ::std::unique_ptr< CollisionErrorFunctiond > |
| |
| using | CollisionErrorFunctiond_w = ::std::weak_ptr< CollisionErrorFunctiond > |
| |
| using | CollisionErrorFunctiond_const_p = ::std::shared_ptr< const CollisionErrorFunctiond > |
| |
| using | CollisionErrorFunctiond_const_u = ::std::unique_ptr< const CollisionErrorFunctiond > |
| |
| using | CollisionErrorFunctiond_const_w = ::std::weak_ptr< const CollisionErrorFunctiond > |
| |
| using | CollisionErrorFunctionStateless = CollisionErrorFunctionStatelessT< float > |
| |
| using | CollisionErrorFunctionStatelessd = CollisionErrorFunctionStatelessT< double > |
| |
| using | CollisionErrorFunctionStateless_p = ::std::shared_ptr< CollisionErrorFunctionStateless > |
| |
| using | CollisionErrorFunctionStateless_u = ::std::unique_ptr< CollisionErrorFunctionStateless > |
| |
| using | CollisionErrorFunctionStateless_w = ::std::weak_ptr< CollisionErrorFunctionStateless > |
| |
| using | CollisionErrorFunctionStateless_const_p = ::std::shared_ptr< const CollisionErrorFunctionStateless > |
| |
| using | CollisionErrorFunctionStateless_const_u = ::std::unique_ptr< const CollisionErrorFunctionStateless > |
| |
| using | CollisionErrorFunctionStateless_const_w = ::std::weak_ptr< const CollisionErrorFunctionStateless > |
| |
| using | CollisionErrorFunctionStatelessd_p = ::std::shared_ptr< CollisionErrorFunctionStatelessd > |
| |
| using | CollisionErrorFunctionStatelessd_u = ::std::unique_ptr< CollisionErrorFunctionStatelessd > |
| |
| using | CollisionErrorFunctionStatelessd_w = ::std::weak_ptr< CollisionErrorFunctionStatelessd > |
| |
| using | CollisionErrorFunctionStatelessd_const_p = ::std::shared_ptr< const CollisionErrorFunctionStatelessd > |
| |
| using | CollisionErrorFunctionStatelessd_const_u = ::std::unique_ptr< const CollisionErrorFunctionStatelessd > |
| |
| using | CollisionErrorFunctionStatelessd_const_w = ::std::weak_ptr< const CollisionErrorFunctionStatelessd > |
| |
| using | DistanceErrorFunction = DistanceErrorFunctionT< float > |
| |
| using | DistanceErrorFunctiond = DistanceErrorFunctionT< double > |
| |
| using | DistanceErrorFunction_p = ::std::shared_ptr< DistanceErrorFunction > |
| |
| using | DistanceErrorFunction_u = ::std::unique_ptr< DistanceErrorFunction > |
| |
| using | DistanceErrorFunction_w = ::std::weak_ptr< DistanceErrorFunction > |
| |
| using | DistanceErrorFunction_const_p = ::std::shared_ptr< const DistanceErrorFunction > |
| |
| using | DistanceErrorFunction_const_u = ::std::unique_ptr< const DistanceErrorFunction > |
| |
| using | DistanceErrorFunction_const_w = ::std::weak_ptr< const DistanceErrorFunction > |
| |
| using | DistanceErrorFunctiond_p = ::std::shared_ptr< DistanceErrorFunctiond > |
| |
| using | DistanceErrorFunctiond_u = ::std::unique_ptr< DistanceErrorFunctiond > |
| |
| using | DistanceErrorFunctiond_w = ::std::weak_ptr< DistanceErrorFunctiond > |
| |
| using | DistanceErrorFunctiond_const_p = ::std::shared_ptr< const DistanceErrorFunctiond > |
| |
| using | DistanceErrorFunctiond_const_u = ::std::unique_ptr< const DistanceErrorFunctiond > |
| |
| using | DistanceErrorFunctiond_const_w = ::std::weak_ptr< const DistanceErrorFunctiond > |
| |
| using | FixedAxisAngleErrorFunction = FixedAxisAngleErrorFunctionT< float > |
| |
| using | FixedAxisAngleErrorFunctiond = FixedAxisAngleErrorFunctionT< double > |
| |
| using | FixedAxisAngleErrorFunction_p = ::std::shared_ptr< FixedAxisAngleErrorFunction > |
| |
| using | FixedAxisAngleErrorFunction_u = ::std::unique_ptr< FixedAxisAngleErrorFunction > |
| |
| using | FixedAxisAngleErrorFunction_w = ::std::weak_ptr< FixedAxisAngleErrorFunction > |
| |
| using | FixedAxisAngleErrorFunction_const_p = ::std::shared_ptr< const FixedAxisAngleErrorFunction > |
| |
| using | FixedAxisAngleErrorFunction_const_u = ::std::unique_ptr< const FixedAxisAngleErrorFunction > |
| |
| using | FixedAxisAngleErrorFunction_const_w = ::std::weak_ptr< const FixedAxisAngleErrorFunction > |
| |
| using | FixedAxisAngleErrorFunctiond_p = ::std::shared_ptr< FixedAxisAngleErrorFunctiond > |
| |
| using | FixedAxisAngleErrorFunctiond_u = ::std::unique_ptr< FixedAxisAngleErrorFunctiond > |
| |
| using | FixedAxisAngleErrorFunctiond_w = ::std::weak_ptr< FixedAxisAngleErrorFunctiond > |
| |
| using | FixedAxisAngleErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisAngleErrorFunctiond > |
| |
| using | FixedAxisAngleErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisAngleErrorFunctiond > |
| |
| using | FixedAxisAngleErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisAngleErrorFunctiond > |
| |
| using | FixedAxisCosErrorFunction = FixedAxisCosErrorFunctionT< float > |
| |
| using | FixedAxisCosErrorFunctiond = FixedAxisCosErrorFunctionT< double > |
| |
| using | FixedAxisCosErrorFunction_p = ::std::shared_ptr< FixedAxisCosErrorFunction > |
| |
| using | FixedAxisCosErrorFunction_u = ::std::unique_ptr< FixedAxisCosErrorFunction > |
| |
| using | FixedAxisCosErrorFunction_w = ::std::weak_ptr< FixedAxisCosErrorFunction > |
| |
| using | FixedAxisCosErrorFunction_const_p = ::std::shared_ptr< const FixedAxisCosErrorFunction > |
| |
| using | FixedAxisCosErrorFunction_const_u = ::std::unique_ptr< const FixedAxisCosErrorFunction > |
| |
| using | FixedAxisCosErrorFunction_const_w = ::std::weak_ptr< const FixedAxisCosErrorFunction > |
| |
| using | FixedAxisCosErrorFunctiond_p = ::std::shared_ptr< FixedAxisCosErrorFunctiond > |
| |
| using | FixedAxisCosErrorFunctiond_u = ::std::unique_ptr< FixedAxisCosErrorFunctiond > |
| |
| using | FixedAxisCosErrorFunctiond_w = ::std::weak_ptr< FixedAxisCosErrorFunctiond > |
| |
| using | FixedAxisCosErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisCosErrorFunctiond > |
| |
| using | FixedAxisCosErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisCosErrorFunctiond > |
| |
| using | FixedAxisCosErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisCosErrorFunctiond > |
| |
| using | FixedAxisDiffErrorFunction = FixedAxisDiffErrorFunctionT< float > |
| |
| using | FixedAxisDiffErrorFunctiond = FixedAxisDiffErrorFunctionT< double > |
| |
| using | FixedAxisDiffErrorFunction_p = ::std::shared_ptr< FixedAxisDiffErrorFunction > |
| |
| using | FixedAxisDiffErrorFunction_u = ::std::unique_ptr< FixedAxisDiffErrorFunction > |
| |
| using | FixedAxisDiffErrorFunction_w = ::std::weak_ptr< FixedAxisDiffErrorFunction > |
| |
| using | FixedAxisDiffErrorFunction_const_p = ::std::shared_ptr< const FixedAxisDiffErrorFunction > |
| |
| using | FixedAxisDiffErrorFunction_const_u = ::std::unique_ptr< const FixedAxisDiffErrorFunction > |
| |
| using | FixedAxisDiffErrorFunction_const_w = ::std::weak_ptr< const FixedAxisDiffErrorFunction > |
| |
| using | FixedAxisDiffErrorFunctiond_p = ::std::shared_ptr< FixedAxisDiffErrorFunctiond > |
| |
| using | FixedAxisDiffErrorFunctiond_u = ::std::unique_ptr< FixedAxisDiffErrorFunctiond > |
| |
| using | FixedAxisDiffErrorFunctiond_w = ::std::weak_ptr< FixedAxisDiffErrorFunctiond > |
| |
| using | FixedAxisDiffErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisDiffErrorFunctiond > |
| |
| using | FixedAxisDiffErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisDiffErrorFunctiond > |
| |
| using | FixedAxisDiffErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisDiffErrorFunctiond > |
| |
| using | GaussNewtonSolverQR = GaussNewtonSolverQRT< float > |
| |
| using | GaussNewtonSolverQRd = GaussNewtonSolverQRT< double > |
| |
| using | GaussNewtonSolverQR_p = ::std::shared_ptr< GaussNewtonSolverQR > |
| |
| using | GaussNewtonSolverQR_u = ::std::unique_ptr< GaussNewtonSolverQR > |
| |
| using | GaussNewtonSolverQR_w = ::std::weak_ptr< GaussNewtonSolverQR > |
| |
| using | GaussNewtonSolverQR_const_p = ::std::shared_ptr< const GaussNewtonSolverQR > |
| |
| using | GaussNewtonSolverQR_const_u = ::std::unique_ptr< const GaussNewtonSolverQR > |
| |
| using | GaussNewtonSolverQR_const_w = ::std::weak_ptr< const GaussNewtonSolverQR > |
| |
| using | GaussNewtonSolverQRd_p = ::std::shared_ptr< GaussNewtonSolverQRd > |
| |
| using | GaussNewtonSolverQRd_u = ::std::unique_ptr< GaussNewtonSolverQRd > |
| |
| using | GaussNewtonSolverQRd_w = ::std::weak_ptr< GaussNewtonSolverQRd > |
| |
| using | GaussNewtonSolverQRd_const_p = ::std::shared_ptr< const GaussNewtonSolverQRd > |
| |
| using | GaussNewtonSolverQRd_const_u = ::std::unique_ptr< const GaussNewtonSolverQRd > |
| |
| using | GaussNewtonSolverQRd_const_w = ::std::weak_ptr< const GaussNewtonSolverQRd > |
| |
| using | HeightErrorFunction = HeightErrorFunctionT< float > |
| |
| using | HeightErrorFunctiond = HeightErrorFunctionT< double > |
| |
| using | HeightErrorFunction_p = ::std::shared_ptr< HeightErrorFunction > |
| |
| using | HeightErrorFunction_u = ::std::unique_ptr< HeightErrorFunction > |
| |
| using | HeightErrorFunction_w = ::std::weak_ptr< HeightErrorFunction > |
| |
| using | HeightErrorFunction_const_p = ::std::shared_ptr< const HeightErrorFunction > |
| |
| using | HeightErrorFunction_const_u = ::std::unique_ptr< const HeightErrorFunction > |
| |
| using | HeightErrorFunction_const_w = ::std::weak_ptr< const HeightErrorFunction > |
| |
| using | HeightErrorFunctiond_p = ::std::shared_ptr< HeightErrorFunctiond > |
| |
| using | HeightErrorFunctiond_u = ::std::unique_ptr< HeightErrorFunctiond > |
| |
| using | HeightErrorFunctiond_w = ::std::weak_ptr< HeightErrorFunctiond > |
| |
| using | HeightErrorFunctiond_const_p = ::std::shared_ptr< const HeightErrorFunctiond > |
| |
| using | HeightErrorFunctiond_const_u = ::std::unique_ptr< const HeightErrorFunctiond > |
| |
| using | HeightErrorFunctiond_const_w = ::std::weak_ptr< const HeightErrorFunctiond > |
| |
| using | LimitErrorFunction = LimitErrorFunctionT< float > |
| |
| using | LimitErrorFunctiond = LimitErrorFunctionT< double > |
| |
| using | LimitErrorFunction_p = ::std::shared_ptr< LimitErrorFunction > |
| |
| using | LimitErrorFunction_u = ::std::unique_ptr< LimitErrorFunction > |
| |
| using | LimitErrorFunction_w = ::std::weak_ptr< LimitErrorFunction > |
| |
| using | LimitErrorFunction_const_p = ::std::shared_ptr< const LimitErrorFunction > |
| |
| using | LimitErrorFunction_const_u = ::std::unique_ptr< const LimitErrorFunction > |
| |
| using | LimitErrorFunction_const_w = ::std::weak_ptr< const LimitErrorFunction > |
| |
| using | LimitErrorFunctiond_p = ::std::shared_ptr< LimitErrorFunctiond > |
| |
| using | LimitErrorFunctiond_u = ::std::unique_ptr< LimitErrorFunctiond > |
| |
| using | LimitErrorFunctiond_w = ::std::weak_ptr< LimitErrorFunctiond > |
| |
| using | LimitErrorFunctiond_const_p = ::std::shared_ptr< const LimitErrorFunctiond > |
| |
| using | LimitErrorFunctiond_const_u = ::std::unique_ptr< const LimitErrorFunctiond > |
| |
| using | LimitErrorFunctiond_const_w = ::std::weak_ptr< const LimitErrorFunctiond > |
| |
| using | ModelParametersErrorFunction = ModelParametersErrorFunctionT< float > |
| |
| using | ModelParametersErrorFunctiond = ModelParametersErrorFunctionT< double > |
| |
| using | ModelParametersErrorFunction_p = ::std::shared_ptr< ModelParametersErrorFunction > |
| |
| using | ModelParametersErrorFunction_u = ::std::unique_ptr< ModelParametersErrorFunction > |
| |
| using | ModelParametersErrorFunction_w = ::std::weak_ptr< ModelParametersErrorFunction > |
| |
| using | ModelParametersErrorFunction_const_p = ::std::shared_ptr< const ModelParametersErrorFunction > |
| |
| using | ModelParametersErrorFunction_const_u = ::std::unique_ptr< const ModelParametersErrorFunction > |
| |
| using | ModelParametersErrorFunction_const_w = ::std::weak_ptr< const ModelParametersErrorFunction > |
| |
| using | ModelParametersErrorFunctiond_p = ::std::shared_ptr< ModelParametersErrorFunctiond > |
| |
| using | ModelParametersErrorFunctiond_u = ::std::unique_ptr< ModelParametersErrorFunctiond > |
| |
| using | ModelParametersErrorFunctiond_w = ::std::weak_ptr< ModelParametersErrorFunctiond > |
| |
| using | ModelParametersErrorFunctiond_const_p = ::std::shared_ptr< const ModelParametersErrorFunctiond > |
| |
| using | ModelParametersErrorFunctiond_const_u = ::std::unique_ptr< const ModelParametersErrorFunctiond > |
| |
| using | ModelParametersErrorFunctiond_const_w = ::std::weak_ptr< const ModelParametersErrorFunctiond > |
| |
| using | NormalErrorFunction = NormalErrorFunctionT< float > |
| |
| using | NormalErrorFunctiond = NormalErrorFunctionT< double > |
| |
| using | NormalErrorFunction_p = ::std::shared_ptr< NormalErrorFunction > |
| |
| using | NormalErrorFunction_u = ::std::unique_ptr< NormalErrorFunction > |
| |
| using | NormalErrorFunction_w = ::std::weak_ptr< NormalErrorFunction > |
| |
| using | NormalErrorFunction_const_p = ::std::shared_ptr< const NormalErrorFunction > |
| |
| using | NormalErrorFunction_const_u = ::std::unique_ptr< const NormalErrorFunction > |
| |
| using | NormalErrorFunction_const_w = ::std::weak_ptr< const NormalErrorFunction > |
| |
| using | NormalErrorFunctiond_p = ::std::shared_ptr< NormalErrorFunctiond > |
| |
| using | NormalErrorFunctiond_u = ::std::unique_ptr< NormalErrorFunctiond > |
| |
| using | NormalErrorFunctiond_w = ::std::weak_ptr< NormalErrorFunctiond > |
| |
| using | NormalErrorFunctiond_const_p = ::std::shared_ptr< const NormalErrorFunctiond > |
| |
| using | NormalErrorFunctiond_const_u = ::std::unique_ptr< const NormalErrorFunctiond > |
| |
| using | NormalErrorFunctiond_const_w = ::std::weak_ptr< const NormalErrorFunctiond > |
| |
| using | OrientationErrorFunction = OrientationErrorFunctionT< float > |
| |
| using | OrientationErrorFunctiond = OrientationErrorFunctionT< double > |
| |
| using | OrientationErrorFunction_p = ::std::shared_ptr< OrientationErrorFunction > |
| |
| using | OrientationErrorFunction_u = ::std::unique_ptr< OrientationErrorFunction > |
| |
| using | OrientationErrorFunction_w = ::std::weak_ptr< OrientationErrorFunction > |
| |
| using | OrientationErrorFunction_const_p = ::std::shared_ptr< const OrientationErrorFunction > |
| |
| using | OrientationErrorFunction_const_u = ::std::unique_ptr< const OrientationErrorFunction > |
| |
| using | OrientationErrorFunction_const_w = ::std::weak_ptr< const OrientationErrorFunction > |
| |
| using | OrientationErrorFunctiond_p = ::std::shared_ptr< OrientationErrorFunctiond > |
| |
| using | OrientationErrorFunctiond_u = ::std::unique_ptr< OrientationErrorFunctiond > |
| |
| using | OrientationErrorFunctiond_w = ::std::weak_ptr< OrientationErrorFunctiond > |
| |
| using | OrientationErrorFunctiond_const_p = ::std::shared_ptr< const OrientationErrorFunctiond > |
| |
| using | OrientationErrorFunctiond_const_u = ::std::unique_ptr< const OrientationErrorFunctiond > |
| |
| using | OrientationErrorFunctiond_const_w = ::std::weak_ptr< const OrientationErrorFunctiond > |
| |
| using | PlaneErrorFunction = PlaneErrorFunctionT< float > |
| |
| using | PlaneErrorFunctiond = PlaneErrorFunctionT< double > |
| |
| using | PlaneErrorFunction_p = ::std::shared_ptr< PlaneErrorFunction > |
| |
| using | PlaneErrorFunction_u = ::std::unique_ptr< PlaneErrorFunction > |
| |
| using | PlaneErrorFunction_w = ::std::weak_ptr< PlaneErrorFunction > |
| |
| using | PlaneErrorFunction_const_p = ::std::shared_ptr< const PlaneErrorFunction > |
| |
| using | PlaneErrorFunction_const_u = ::std::unique_ptr< const PlaneErrorFunction > |
| |
| using | PlaneErrorFunction_const_w = ::std::weak_ptr< const PlaneErrorFunction > |
| |
| using | PlaneErrorFunctiond_p = ::std::shared_ptr< PlaneErrorFunctiond > |
| |
| using | PlaneErrorFunctiond_u = ::std::unique_ptr< PlaneErrorFunctiond > |
| |
| using | PlaneErrorFunctiond_w = ::std::weak_ptr< PlaneErrorFunctiond > |
| |
| using | PlaneErrorFunctiond_const_p = ::std::shared_ptr< const PlaneErrorFunctiond > |
| |
| using | PlaneErrorFunctiond_const_u = ::std::unique_ptr< const PlaneErrorFunctiond > |
| |
| using | PlaneErrorFunctiond_const_w = ::std::weak_ptr< const PlaneErrorFunctiond > |
| |
| using | PointTriangleVertexErrorFunction = PointTriangleVertexErrorFunctionT< float > |
| |
| using | PointTriangleVertexErrorFunctiond = PointTriangleVertexErrorFunctionT< double > |
| |
| using | PointTriangleVertexErrorFunction_p = ::std::shared_ptr< PointTriangleVertexErrorFunction > |
| |
| using | PointTriangleVertexErrorFunction_u = ::std::unique_ptr< PointTriangleVertexErrorFunction > |
| |
| using | PointTriangleVertexErrorFunction_w = ::std::weak_ptr< PointTriangleVertexErrorFunction > |
| |
| using | PointTriangleVertexErrorFunction_const_p = ::std::shared_ptr< const PointTriangleVertexErrorFunction > |
| |
| using | PointTriangleVertexErrorFunction_const_u = ::std::unique_ptr< const PointTriangleVertexErrorFunction > |
| |
| using | PointTriangleVertexErrorFunction_const_w = ::std::weak_ptr< const PointTriangleVertexErrorFunction > |
| |
| using | PointTriangleVertexErrorFunctiond_p = ::std::shared_ptr< PointTriangleVertexErrorFunctiond > |
| |
| using | PointTriangleVertexErrorFunctiond_u = ::std::unique_ptr< PointTriangleVertexErrorFunctiond > |
| |
| using | PointTriangleVertexErrorFunctiond_w = ::std::weak_ptr< PointTriangleVertexErrorFunctiond > |
| |
| using | PointTriangleVertexErrorFunctiond_const_p = ::std::shared_ptr< const PointTriangleVertexErrorFunctiond > |
| |
| using | PointTriangleVertexErrorFunctiond_const_u = ::std::unique_ptr< const PointTriangleVertexErrorFunctiond > |
| |
| using | PointTriangleVertexErrorFunctiond_const_w = ::std::weak_ptr< const PointTriangleVertexErrorFunctiond > |
| |
| using | PosePriorErrorFunction = PosePriorErrorFunctionT< float > |
| |
| using | PosePriorErrorFunctiond = PosePriorErrorFunctionT< double > |
| |
| using | PosePriorErrorFunction_p = ::std::shared_ptr< PosePriorErrorFunction > |
| |
| using | PosePriorErrorFunction_u = ::std::unique_ptr< PosePriorErrorFunction > |
| |
| using | PosePriorErrorFunction_w = ::std::weak_ptr< PosePriorErrorFunction > |
| |
| using | PosePriorErrorFunction_const_p = ::std::shared_ptr< const PosePriorErrorFunction > |
| |
| using | PosePriorErrorFunction_const_u = ::std::unique_ptr< const PosePriorErrorFunction > |
| |
| using | PosePriorErrorFunction_const_w = ::std::weak_ptr< const PosePriorErrorFunction > |
| |
| using | PosePriorErrorFunctiond_p = ::std::shared_ptr< PosePriorErrorFunctiond > |
| |
| using | PosePriorErrorFunctiond_u = ::std::unique_ptr< PosePriorErrorFunctiond > |
| |
| using | PosePriorErrorFunctiond_w = ::std::weak_ptr< PosePriorErrorFunctiond > |
| |
| using | PosePriorErrorFunctiond_const_p = ::std::shared_ptr< const PosePriorErrorFunctiond > |
| |
| using | PosePriorErrorFunctiond_const_u = ::std::unique_ptr< const PosePriorErrorFunctiond > |
| |
| using | PosePriorErrorFunctiond_const_w = ::std::weak_ptr< const PosePriorErrorFunctiond > |
| |
| using | PoseTransformSolver = PoseTransformSolverT< float > |
| |
| using | PoseTransformSolverd = PoseTransformSolverT< double > |
| |
| using | PoseTransformSolver_p = ::std::shared_ptr< PoseTransformSolver > |
| |
| using | PoseTransformSolver_u = ::std::unique_ptr< PoseTransformSolver > |
| |
| using | PoseTransformSolver_w = ::std::weak_ptr< PoseTransformSolver > |
| |
| using | PoseTransformSolver_const_p = ::std::shared_ptr< const PoseTransformSolver > |
| |
| using | PoseTransformSolver_const_u = ::std::unique_ptr< const PoseTransformSolver > |
| |
| using | PoseTransformSolver_const_w = ::std::weak_ptr< const PoseTransformSolver > |
| |
| using | PoseTransformSolverd_p = ::std::shared_ptr< PoseTransformSolverd > |
| |
| using | PoseTransformSolverd_u = ::std::unique_ptr< PoseTransformSolverd > |
| |
| using | PoseTransformSolverd_w = ::std::weak_ptr< PoseTransformSolverd > |
| |
| using | PoseTransformSolverd_const_p = ::std::shared_ptr< const PoseTransformSolverd > |
| |
| using | PoseTransformSolverd_const_u = ::std::unique_ptr< const PoseTransformSolverd > |
| |
| using | PoseTransformSolverd_const_w = ::std::weak_ptr< const PoseTransformSolverd > |
| |
| using | PositionErrorFunction = PositionErrorFunctionT< float > |
| |
| using | PositionErrorFunctiond = PositionErrorFunctionT< double > |
| |
| using | PositionErrorFunction_p = ::std::shared_ptr< PositionErrorFunction > |
| |
| using | PositionErrorFunction_u = ::std::unique_ptr< PositionErrorFunction > |
| |
| using | PositionErrorFunction_w = ::std::weak_ptr< PositionErrorFunction > |
| |
| using | PositionErrorFunction_const_p = ::std::shared_ptr< const PositionErrorFunction > |
| |
| using | PositionErrorFunction_const_u = ::std::unique_ptr< const PositionErrorFunction > |
| |
| using | PositionErrorFunction_const_w = ::std::weak_ptr< const PositionErrorFunction > |
| |
| using | PositionErrorFunctiond_p = ::std::shared_ptr< PositionErrorFunctiond > |
| |
| using | PositionErrorFunctiond_u = ::std::unique_ptr< PositionErrorFunctiond > |
| |
| using | PositionErrorFunctiond_w = ::std::weak_ptr< PositionErrorFunctiond > |
| |
| using | PositionErrorFunctiond_const_p = ::std::shared_ptr< const PositionErrorFunctiond > |
| |
| using | PositionErrorFunctiond_const_u = ::std::unique_ptr< const PositionErrorFunctiond > |
| |
| using | PositionErrorFunctiond_const_w = ::std::weak_ptr< const PositionErrorFunctiond > |
| |
| using | ProjectionErrorFunction = ProjectionErrorFunctionT< float > |
| |
| using | ProjectionErrorFunctiond = ProjectionErrorFunctionT< double > |
| |
| using | ProjectionErrorFunction_p = ::std::shared_ptr< ProjectionErrorFunction > |
| |
| using | ProjectionErrorFunction_u = ::std::unique_ptr< ProjectionErrorFunction > |
| |
| using | ProjectionErrorFunction_w = ::std::weak_ptr< ProjectionErrorFunction > |
| |
| using | ProjectionErrorFunction_const_p = ::std::shared_ptr< const ProjectionErrorFunction > |
| |
| using | ProjectionErrorFunction_const_u = ::std::unique_ptr< const ProjectionErrorFunction > |
| |
| using | ProjectionErrorFunction_const_w = ::std::weak_ptr< const ProjectionErrorFunction > |
| |
| using | ProjectionErrorFunctiond_p = ::std::shared_ptr< ProjectionErrorFunctiond > |
| |
| using | ProjectionErrorFunctiond_u = ::std::unique_ptr< ProjectionErrorFunctiond > |
| |
| using | ProjectionErrorFunctiond_w = ::std::weak_ptr< ProjectionErrorFunctiond > |
| |
| using | ProjectionErrorFunctiond_const_p = ::std::shared_ptr< const ProjectionErrorFunctiond > |
| |
| using | ProjectionErrorFunctiond_const_u = ::std::unique_ptr< const ProjectionErrorFunctiond > |
| |
| using | ProjectionErrorFunctiond_const_w = ::std::weak_ptr< const ProjectionErrorFunctiond > |
| |
| using | SimdCollisionErrorFunction = SimdCollisionErrorFunctionT< float > |
| |
| using | SimdCollisionErrorFunctiond = SimdCollisionErrorFunctionT< double > |
| |
| using | SimdCollisionErrorFunction_p = ::std::shared_ptr< SimdCollisionErrorFunction > |
| |
| using | SimdCollisionErrorFunction_u = ::std::unique_ptr< SimdCollisionErrorFunction > |
| |
| using | SimdCollisionErrorFunction_w = ::std::weak_ptr< SimdCollisionErrorFunction > |
| |
| using | SimdCollisionErrorFunction_const_p = ::std::shared_ptr< const SimdCollisionErrorFunction > |
| |
| using | SimdCollisionErrorFunction_const_u = ::std::unique_ptr< const SimdCollisionErrorFunction > |
| |
| using | SimdCollisionErrorFunction_const_w = ::std::weak_ptr< const SimdCollisionErrorFunction > |
| |
| using | SimdCollisionErrorFunctiond_p = ::std::shared_ptr< SimdCollisionErrorFunctiond > |
| |
| using | SimdCollisionErrorFunctiond_u = ::std::unique_ptr< SimdCollisionErrorFunctiond > |
| |
| using | SimdCollisionErrorFunctiond_w = ::std::weak_ptr< SimdCollisionErrorFunctiond > |
| |
| using | SimdCollisionErrorFunctiond_const_p = ::std::shared_ptr< const SimdCollisionErrorFunctiond > |
| |
| using | SimdCollisionErrorFunctiond_const_u = ::std::unique_ptr< const SimdCollisionErrorFunctiond > |
| |
| using | SimdCollisionErrorFunctiond_const_w = ::std::weak_ptr< const SimdCollisionErrorFunctiond > |
| |
| using | SkeletonErrorFunction = SkeletonErrorFunctionT< float > |
| |
| using | SkeletonErrorFunctiond = SkeletonErrorFunctionT< double > |
| |
| using | SkeletonErrorFunction_p = ::std::shared_ptr< SkeletonErrorFunction > |
| |
| using | SkeletonErrorFunction_u = ::std::unique_ptr< SkeletonErrorFunction > |
| |
| using | SkeletonErrorFunction_w = ::std::weak_ptr< SkeletonErrorFunction > |
| |
| using | SkeletonErrorFunction_const_p = ::std::shared_ptr< const SkeletonErrorFunction > |
| |
| using | SkeletonErrorFunction_const_u = ::std::unique_ptr< const SkeletonErrorFunction > |
| |
| using | SkeletonErrorFunction_const_w = ::std::weak_ptr< const SkeletonErrorFunction > |
| |
| using | SkeletonErrorFunctiond_p = ::std::shared_ptr< SkeletonErrorFunctiond > |
| |
| using | SkeletonErrorFunctiond_u = ::std::unique_ptr< SkeletonErrorFunctiond > |
| |
| using | SkeletonErrorFunctiond_w = ::std::weak_ptr< SkeletonErrorFunctiond > |
| |
| using | SkeletonErrorFunctiond_const_p = ::std::shared_ptr< const SkeletonErrorFunctiond > |
| |
| using | SkeletonErrorFunctiond_const_u = ::std::unique_ptr< const SkeletonErrorFunctiond > |
| |
| using | SkeletonErrorFunctiond_const_w = ::std::weak_ptr< const SkeletonErrorFunctiond > |
| |
| using | SkeletonSolverFunction = SkeletonSolverFunctionT< float > |
| |
| using | SkeletonSolverFunctiond = SkeletonSolverFunctionT< double > |
| |
| using | SkeletonSolverFunction_p = ::std::shared_ptr< SkeletonSolverFunction > |
| |
| using | SkeletonSolverFunction_u = ::std::unique_ptr< SkeletonSolverFunction > |
| |
| using | SkeletonSolverFunction_w = ::std::weak_ptr< SkeletonSolverFunction > |
| |
| using | SkeletonSolverFunction_const_p = ::std::shared_ptr< const SkeletonSolverFunction > |
| |
| using | SkeletonSolverFunction_const_u = ::std::unique_ptr< const SkeletonSolverFunction > |
| |
| using | SkeletonSolverFunction_const_w = ::std::weak_ptr< const SkeletonSolverFunction > |
| |
| using | SkeletonSolverFunctiond_p = ::std::shared_ptr< SkeletonSolverFunctiond > |
| |
| using | SkeletonSolverFunctiond_u = ::std::unique_ptr< SkeletonSolverFunctiond > |
| |
| using | SkeletonSolverFunctiond_w = ::std::weak_ptr< SkeletonSolverFunctiond > |
| |
| using | SkeletonSolverFunctiond_const_p = ::std::shared_ptr< const SkeletonSolverFunctiond > |
| |
| using | SkeletonSolverFunctiond_const_u = ::std::unique_ptr< const SkeletonSolverFunctiond > |
| |
| using | SkeletonSolverFunctiond_const_w = ::std::weak_ptr< const SkeletonSolverFunctiond > |
| |
| using | SkinnedLocatorErrorFunction = SkinnedLocatorErrorFunctionT< float > |
| |
| using | SkinnedLocatorErrorFunctiond = SkinnedLocatorErrorFunctionT< double > |
| |
| using | SkinnedLocatorErrorFunction_p = ::std::shared_ptr< SkinnedLocatorErrorFunction > |
| |
| using | SkinnedLocatorErrorFunction_u = ::std::unique_ptr< SkinnedLocatorErrorFunction > |
| |
| using | SkinnedLocatorErrorFunction_w = ::std::weak_ptr< SkinnedLocatorErrorFunction > |
| |
| using | SkinnedLocatorErrorFunction_const_p = ::std::shared_ptr< const SkinnedLocatorErrorFunction > |
| |
| using | SkinnedLocatorErrorFunction_const_u = ::std::unique_ptr< const SkinnedLocatorErrorFunction > |
| |
| using | SkinnedLocatorErrorFunction_const_w = ::std::weak_ptr< const SkinnedLocatorErrorFunction > |
| |
| using | SkinnedLocatorErrorFunctiond_p = ::std::shared_ptr< SkinnedLocatorErrorFunctiond > |
| |
| using | SkinnedLocatorErrorFunctiond_u = ::std::unique_ptr< SkinnedLocatorErrorFunctiond > |
| |
| using | SkinnedLocatorErrorFunctiond_w = ::std::weak_ptr< SkinnedLocatorErrorFunctiond > |
| |
| using | SkinnedLocatorErrorFunctiond_const_p = ::std::shared_ptr< const SkinnedLocatorErrorFunctiond > |
| |
| using | SkinnedLocatorErrorFunctiond_const_u = ::std::unique_ptr< const SkinnedLocatorErrorFunctiond > |
| |
| using | SkinnedLocatorErrorFunctiond_const_w = ::std::weak_ptr< const SkinnedLocatorErrorFunctiond > |
| |
| using | SkinnedLocatorTriangleErrorFunction = SkinnedLocatorTriangleErrorFunctionT< float > |
| |
| using | SkinnedLocatorTriangleErrorFunctiond = SkinnedLocatorTriangleErrorFunctionT< double > |
| |
| using | SkinnedLocatorTriangleErrorFunction_p = ::std::shared_ptr< SkinnedLocatorTriangleErrorFunction > |
| |
| using | SkinnedLocatorTriangleErrorFunction_u = ::std::unique_ptr< SkinnedLocatorTriangleErrorFunction > |
| |
| using | SkinnedLocatorTriangleErrorFunction_w = ::std::weak_ptr< SkinnedLocatorTriangleErrorFunction > |
| |
| using | SkinnedLocatorTriangleErrorFunction_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleErrorFunction > |
| |
| using | SkinnedLocatorTriangleErrorFunction_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleErrorFunction > |
| |
| using | SkinnedLocatorTriangleErrorFunction_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleErrorFunction > |
| |
| using | SkinnedLocatorTriangleErrorFunctiond_p = ::std::shared_ptr< SkinnedLocatorTriangleErrorFunctiond > |
| |
| using | SkinnedLocatorTriangleErrorFunctiond_u = ::std::unique_ptr< SkinnedLocatorTriangleErrorFunctiond > |
| |
| using | SkinnedLocatorTriangleErrorFunctiond_w = ::std::weak_ptr< SkinnedLocatorTriangleErrorFunctiond > |
| |
| using | SkinnedLocatorTriangleErrorFunctiond_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleErrorFunctiond > |
| |
| using | SkinnedLocatorTriangleErrorFunctiond_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleErrorFunctiond > |
| |
| using | SkinnedLocatorTriangleErrorFunctiond_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleErrorFunctiond > |
| |
| using | StateErrorFunction = StateErrorFunctionT< float > |
| |
| using | StateErrorFunctiond = StateErrorFunctionT< double > |
| |
| using | StateErrorFunction_p = ::std::shared_ptr< StateErrorFunction > |
| |
| using | StateErrorFunction_u = ::std::unique_ptr< StateErrorFunction > |
| |
| using | StateErrorFunction_w = ::std::weak_ptr< StateErrorFunction > |
| |
| using | StateErrorFunction_const_p = ::std::shared_ptr< const StateErrorFunction > |
| |
| using | StateErrorFunction_const_u = ::std::unique_ptr< const StateErrorFunction > |
| |
| using | StateErrorFunction_const_w = ::std::weak_ptr< const StateErrorFunction > |
| |
| using | StateErrorFunctiond_p = ::std::shared_ptr< StateErrorFunctiond > |
| |
| using | StateErrorFunctiond_u = ::std::unique_ptr< StateErrorFunctiond > |
| |
| using | StateErrorFunctiond_w = ::std::weak_ptr< StateErrorFunctiond > |
| |
| using | StateErrorFunctiond_const_p = ::std::shared_ptr< const StateErrorFunctiond > |
| |
| using | StateErrorFunctiond_const_u = ::std::unique_ptr< const StateErrorFunctiond > |
| |
| using | StateErrorFunctiond_const_w = ::std::weak_ptr< const StateErrorFunctiond > |
| |
| using | TrustRegionQR = TrustRegionQRT< float > |
| |
| using | TrustRegionQRd = TrustRegionQRT< double > |
| |
| using | TrustRegionQR_p = ::std::shared_ptr< TrustRegionQR > |
| |
| using | TrustRegionQR_u = ::std::unique_ptr< TrustRegionQR > |
| |
| using | TrustRegionQR_w = ::std::weak_ptr< TrustRegionQR > |
| |
| using | TrustRegionQR_const_p = ::std::shared_ptr< const TrustRegionQR > |
| |
| using | TrustRegionQR_const_u = ::std::unique_ptr< const TrustRegionQR > |
| |
| using | TrustRegionQR_const_w = ::std::weak_ptr< const TrustRegionQR > |
| |
| using | TrustRegionQRd_p = ::std::shared_ptr< TrustRegionQRd > |
| |
| using | TrustRegionQRd_u = ::std::unique_ptr< TrustRegionQRd > |
| |
| using | TrustRegionQRd_w = ::std::weak_ptr< TrustRegionQRd > |
| |
| using | TrustRegionQRd_const_p = ::std::shared_ptr< const TrustRegionQRd > |
| |
| using | TrustRegionQRd_const_u = ::std::unique_ptr< const TrustRegionQRd > |
| |
| using | TrustRegionQRd_const_w = ::std::weak_ptr< const TrustRegionQRd > |
| |
| using | VertexErrorFunction = VertexErrorFunctionT< float > |
| |
| using | VertexErrorFunctiond = VertexErrorFunctionT< double > |
| |
| using | VertexErrorFunction_p = ::std::shared_ptr< VertexErrorFunction > |
| |
| using | VertexErrorFunction_u = ::std::unique_ptr< VertexErrorFunction > |
| |
| using | VertexErrorFunction_w = ::std::weak_ptr< VertexErrorFunction > |
| |
| using | VertexErrorFunction_const_p = ::std::shared_ptr< const VertexErrorFunction > |
| |
| using | VertexErrorFunction_const_u = ::std::unique_ptr< const VertexErrorFunction > |
| |
| using | VertexErrorFunction_const_w = ::std::weak_ptr< const VertexErrorFunction > |
| |
| using | VertexErrorFunctiond_p = ::std::shared_ptr< VertexErrorFunctiond > |
| |
| using | VertexErrorFunctiond_u = ::std::unique_ptr< VertexErrorFunctiond > |
| |
| using | VertexErrorFunctiond_w = ::std::weak_ptr< VertexErrorFunctiond > |
| |
| using | VertexErrorFunctiond_const_p = ::std::shared_ptr< const VertexErrorFunctiond > |
| |
| using | VertexErrorFunctiond_const_u = ::std::unique_ptr< const VertexErrorFunctiond > |
| |
| using | VertexErrorFunctiond_const_w = ::std::weak_ptr< const VertexErrorFunctiond > |
| |
| using | VertexProjectionErrorFunction = VertexProjectionErrorFunctionT< float > |
| |
| using | VertexProjectionErrorFunctiond = VertexProjectionErrorFunctionT< double > |
| |
| using | VertexProjectionErrorFunction_p = ::std::shared_ptr< VertexProjectionErrorFunction > |
| |
| using | VertexProjectionErrorFunction_u = ::std::unique_ptr< VertexProjectionErrorFunction > |
| |
| using | VertexProjectionErrorFunction_w = ::std::weak_ptr< VertexProjectionErrorFunction > |
| |
| using | VertexProjectionErrorFunction_const_p = ::std::shared_ptr< const VertexProjectionErrorFunction > |
| |
| using | VertexProjectionErrorFunction_const_u = ::std::unique_ptr< const VertexProjectionErrorFunction > |
| |
| using | VertexProjectionErrorFunction_const_w = ::std::weak_ptr< const VertexProjectionErrorFunction > |
| |
| using | VertexProjectionErrorFunctiond_p = ::std::shared_ptr< VertexProjectionErrorFunctiond > |
| |
| using | VertexProjectionErrorFunctiond_u = ::std::unique_ptr< VertexProjectionErrorFunctiond > |
| |
| using | VertexProjectionErrorFunctiond_w = ::std::weak_ptr< VertexProjectionErrorFunctiond > |
| |
| using | VertexProjectionErrorFunctiond_const_p = ::std::shared_ptr< const VertexProjectionErrorFunctiond > |
| |
| using | VertexProjectionErrorFunctiond_const_u = ::std::unique_ptr< const VertexProjectionErrorFunctiond > |
| |
| using | VertexProjectionErrorFunctiond_const_w = ::std::weak_ptr< const VertexProjectionErrorFunctiond > |
| |
| using | VertexVertexDistanceErrorFunction = VertexVertexDistanceErrorFunctionT< float > |
| |
| using | VertexVertexDistanceErrorFunctiond = VertexVertexDistanceErrorFunctionT< double > |
| |
| using | VertexVertexDistanceErrorFunction_p = ::std::shared_ptr< VertexVertexDistanceErrorFunction > |
| |
| using | VertexVertexDistanceErrorFunction_u = ::std::unique_ptr< VertexVertexDistanceErrorFunction > |
| |
| using | VertexVertexDistanceErrorFunction_w = ::std::weak_ptr< VertexVertexDistanceErrorFunction > |
| |
| using | VertexVertexDistanceErrorFunction_const_p = ::std::shared_ptr< const VertexVertexDistanceErrorFunction > |
| |
| using | VertexVertexDistanceErrorFunction_const_u = ::std::unique_ptr< const VertexVertexDistanceErrorFunction > |
| |
| using | VertexVertexDistanceErrorFunction_const_w = ::std::weak_ptr< const VertexVertexDistanceErrorFunction > |
| |
| using | VertexVertexDistanceErrorFunctiond_p = ::std::shared_ptr< VertexVertexDistanceErrorFunctiond > |
| |
| using | VertexVertexDistanceErrorFunctiond_u = ::std::unique_ptr< VertexVertexDistanceErrorFunctiond > |
| |
| using | VertexVertexDistanceErrorFunctiond_w = ::std::weak_ptr< VertexVertexDistanceErrorFunctiond > |
| |
| using | VertexVertexDistanceErrorFunctiond_const_p = ::std::shared_ptr< const VertexVertexDistanceErrorFunctiond > |
| |
| using | VertexVertexDistanceErrorFunctiond_const_u = ::std::unique_ptr< const VertexVertexDistanceErrorFunctiond > |
| |
| using | VertexVertexDistanceErrorFunctiond_const_w = ::std::weak_ptr< const VertexVertexDistanceErrorFunctiond > |
| |
| using | MultiposeSolverOptions_p = ::std::shared_ptr< MultiposeSolverOptions > |
| |
| using | MultiposeSolverOptions_u = ::std::unique_ptr< MultiposeSolverOptions > |
| |
| using | MultiposeSolverOptions_w = ::std::weak_ptr< MultiposeSolverOptions > |
| |
| using | MultiposeSolverOptions_const_p = ::std::shared_ptr< const MultiposeSolverOptions > |
| |
| using | MultiposeSolverOptions_const_u = ::std::unique_ptr< const MultiposeSolverOptions > |
| |
| using | MultiposeSolverOptions_const_w = ::std::weak_ptr< const MultiposeSolverOptions > |
| |
| using | SequenceSolverOptions_p = ::std::shared_ptr< SequenceSolverOptions > |
| |
| using | SequenceSolverOptions_u = ::std::unique_ptr< SequenceSolverOptions > |
| |
| using | SequenceSolverOptions_w = ::std::weak_ptr< SequenceSolverOptions > |
| |
| using | SequenceSolverOptions_const_p = ::std::shared_ptr< const SequenceSolverOptions > |
| |
| using | SequenceSolverOptions_const_u = ::std::unique_ptr< const SequenceSolverOptions > |
| |
| using | SequenceSolverOptions_const_w = ::std::weak_ptr< const SequenceSolverOptions > |
| |
| using | SequenceErrorFunction = SequenceErrorFunctionT< float > |
| |
| using | SequenceErrorFunctiond = SequenceErrorFunctionT< double > |
| |
| using | SequenceErrorFunction_p = ::std::shared_ptr< SequenceErrorFunction > |
| |
| using | SequenceErrorFunction_u = ::std::unique_ptr< SequenceErrorFunction > |
| |
| using | SequenceErrorFunction_w = ::std::weak_ptr< SequenceErrorFunction > |
| |
| using | SequenceErrorFunction_const_p = ::std::shared_ptr< const SequenceErrorFunction > |
| |
| using | SequenceErrorFunction_const_u = ::std::unique_ptr< const SequenceErrorFunction > |
| |
| using | SequenceErrorFunction_const_w = ::std::weak_ptr< const SequenceErrorFunction > |
| |
| using | SequenceErrorFunctiond_p = ::std::shared_ptr< SequenceErrorFunctiond > |
| |
| using | SequenceErrorFunctiond_u = ::std::unique_ptr< SequenceErrorFunctiond > |
| |
| using | SequenceErrorFunctiond_w = ::std::weak_ptr< SequenceErrorFunctiond > |
| |
| using | SequenceErrorFunctiond_const_p = ::std::shared_ptr< const SequenceErrorFunctiond > |
| |
| using | SequenceErrorFunctiond_const_u = ::std::unique_ptr< const SequenceErrorFunctiond > |
| |
| using | SequenceErrorFunctiond_const_w = ::std::weak_ptr< const SequenceErrorFunctiond > |
| |
| using | ModelParametersSequenceErrorFunction = ModelParametersSequenceErrorFunctionT< float > |
| |
| using | ModelParametersSequenceErrorFunctiond = ModelParametersSequenceErrorFunctionT< double > |
| |
| using | ModelParametersSequenceErrorFunction_p = ::std::shared_ptr< ModelParametersSequenceErrorFunction > |
| |
| using | ModelParametersSequenceErrorFunction_u = ::std::unique_ptr< ModelParametersSequenceErrorFunction > |
| |
| using | ModelParametersSequenceErrorFunction_w = ::std::weak_ptr< ModelParametersSequenceErrorFunction > |
| |
| using | ModelParametersSequenceErrorFunction_const_p = ::std::shared_ptr< const ModelParametersSequenceErrorFunction > |
| |
| using | ModelParametersSequenceErrorFunction_const_u = ::std::unique_ptr< const ModelParametersSequenceErrorFunction > |
| |
| using | ModelParametersSequenceErrorFunction_const_w = ::std::weak_ptr< const ModelParametersSequenceErrorFunction > |
| |
| using | ModelParametersSequenceErrorFunctiond_p = ::std::shared_ptr< ModelParametersSequenceErrorFunctiond > |
| |
| using | ModelParametersSequenceErrorFunctiond_u = ::std::unique_ptr< ModelParametersSequenceErrorFunctiond > |
| |
| using | ModelParametersSequenceErrorFunctiond_w = ::std::weak_ptr< ModelParametersSequenceErrorFunctiond > |
| |
| using | ModelParametersSequenceErrorFunctiond_const_p = ::std::shared_ptr< const ModelParametersSequenceErrorFunctiond > |
| |
| using | ModelParametersSequenceErrorFunctiond_const_u = ::std::unique_ptr< const ModelParametersSequenceErrorFunctiond > |
| |
| using | ModelParametersSequenceErrorFunctiond_const_w = ::std::weak_ptr< const ModelParametersSequenceErrorFunctiond > |
| |
| using | MultiposeSolver = MultiposeSolverT< float > |
| |
| using | MultiposeSolverd = MultiposeSolverT< double > |
| |
| using | MultiposeSolver_p = ::std::shared_ptr< MultiposeSolver > |
| |
| using | MultiposeSolver_u = ::std::unique_ptr< MultiposeSolver > |
| |
| using | MultiposeSolver_w = ::std::weak_ptr< MultiposeSolver > |
| |
| using | MultiposeSolver_const_p = ::std::shared_ptr< const MultiposeSolver > |
| |
| using | MultiposeSolver_const_u = ::std::unique_ptr< const MultiposeSolver > |
| |
| using | MultiposeSolver_const_w = ::std::weak_ptr< const MultiposeSolver > |
| |
| using | MultiposeSolverd_p = ::std::shared_ptr< MultiposeSolverd > |
| |
| using | MultiposeSolverd_u = ::std::unique_ptr< MultiposeSolverd > |
| |
| using | MultiposeSolverd_w = ::std::weak_ptr< MultiposeSolverd > |
| |
| using | MultiposeSolverd_const_p = ::std::shared_ptr< const MultiposeSolverd > |
| |
| using | MultiposeSolverd_const_u = ::std::unique_ptr< const MultiposeSolverd > |
| |
| using | MultiposeSolverd_const_w = ::std::weak_ptr< const MultiposeSolverd > |
| |
| using | MultiposeSolverFunction = MultiposeSolverFunctionT< float > |
| |
| using | MultiposeSolverFunctiond = MultiposeSolverFunctionT< double > |
| |
| using | MultiposeSolverFunction_p = ::std::shared_ptr< MultiposeSolverFunction > |
| |
| using | MultiposeSolverFunction_u = ::std::unique_ptr< MultiposeSolverFunction > |
| |
| using | MultiposeSolverFunction_w = ::std::weak_ptr< MultiposeSolverFunction > |
| |
| using | MultiposeSolverFunction_const_p = ::std::shared_ptr< const MultiposeSolverFunction > |
| |
| using | MultiposeSolverFunction_const_u = ::std::unique_ptr< const MultiposeSolverFunction > |
| |
| using | MultiposeSolverFunction_const_w = ::std::weak_ptr< const MultiposeSolverFunction > |
| |
| using | MultiposeSolverFunctiond_p = ::std::shared_ptr< MultiposeSolverFunctiond > |
| |
| using | MultiposeSolverFunctiond_u = ::std::unique_ptr< MultiposeSolverFunctiond > |
| |
| using | MultiposeSolverFunctiond_w = ::std::weak_ptr< MultiposeSolverFunctiond > |
| |
| using | MultiposeSolverFunctiond_const_p = ::std::shared_ptr< const MultiposeSolverFunctiond > |
| |
| using | MultiposeSolverFunctiond_const_u = ::std::unique_ptr< const MultiposeSolverFunctiond > |
| |
| using | MultiposeSolverFunctiond_const_w = ::std::weak_ptr< const MultiposeSolverFunctiond > |
| |
| using | SequenceSolver = SequenceSolverT< float > |
| |
| using | SequenceSolverd = SequenceSolverT< double > |
| |
| using | SequenceSolver_p = ::std::shared_ptr< SequenceSolver > |
| |
| using | SequenceSolver_u = ::std::unique_ptr< SequenceSolver > |
| |
| using | SequenceSolver_w = ::std::weak_ptr< SequenceSolver > |
| |
| using | SequenceSolver_const_p = ::std::shared_ptr< const SequenceSolver > |
| |
| using | SequenceSolver_const_u = ::std::unique_ptr< const SequenceSolver > |
| |
| using | SequenceSolver_const_w = ::std::weak_ptr< const SequenceSolver > |
| |
| using | SequenceSolverd_p = ::std::shared_ptr< SequenceSolverd > |
| |
| using | SequenceSolverd_u = ::std::unique_ptr< SequenceSolverd > |
| |
| using | SequenceSolverd_w = ::std::weak_ptr< SequenceSolverd > |
| |
| using | SequenceSolverd_const_p = ::std::shared_ptr< const SequenceSolverd > |
| |
| using | SequenceSolverd_const_u = ::std::unique_ptr< const SequenceSolverd > |
| |
| using | SequenceSolverd_const_w = ::std::weak_ptr< const SequenceSolverd > |
| |
| using | SequenceSolverFunction = SequenceSolverFunctionT< float > |
| |
| using | SequenceSolverFunctiond = SequenceSolverFunctionT< double > |
| |
| using | SequenceSolverFunction_p = ::std::shared_ptr< SequenceSolverFunction > |
| |
| using | SequenceSolverFunction_u = ::std::unique_ptr< SequenceSolverFunction > |
| |
| using | SequenceSolverFunction_w = ::std::weak_ptr< SequenceSolverFunction > |
| |
| using | SequenceSolverFunction_const_p = ::std::shared_ptr< const SequenceSolverFunction > |
| |
| using | SequenceSolverFunction_const_u = ::std::unique_ptr< const SequenceSolverFunction > |
| |
| using | SequenceSolverFunction_const_w = ::std::weak_ptr< const SequenceSolverFunction > |
| |
| using | SequenceSolverFunctiond_p = ::std::shared_ptr< SequenceSolverFunctiond > |
| |
| using | SequenceSolverFunctiond_u = ::std::unique_ptr< SequenceSolverFunctiond > |
| |
| using | SequenceSolverFunctiond_w = ::std::weak_ptr< SequenceSolverFunctiond > |
| |
| using | SequenceSolverFunctiond_const_p = ::std::shared_ptr< const SequenceSolverFunctiond > |
| |
| using | SequenceSolverFunctiond_const_u = ::std::unique_ptr< const SequenceSolverFunctiond > |
| |
| using | SequenceSolverFunctiond_const_w = ::std::weak_ptr< const SequenceSolverFunctiond > |
| |
| using | StateSequenceErrorFunction = StateSequenceErrorFunctionT< float > |
| |
| using | StateSequenceErrorFunctiond = StateSequenceErrorFunctionT< double > |
| |
| using | StateSequenceErrorFunction_p = ::std::shared_ptr< StateSequenceErrorFunction > |
| |
| using | StateSequenceErrorFunction_u = ::std::unique_ptr< StateSequenceErrorFunction > |
| |
| using | StateSequenceErrorFunction_w = ::std::weak_ptr< StateSequenceErrorFunction > |
| |
| using | StateSequenceErrorFunction_const_p = ::std::shared_ptr< const StateSequenceErrorFunction > |
| |
| using | StateSequenceErrorFunction_const_u = ::std::unique_ptr< const StateSequenceErrorFunction > |
| |
| using | StateSequenceErrorFunction_const_w = ::std::weak_ptr< const StateSequenceErrorFunction > |
| |
| using | StateSequenceErrorFunctiond_p = ::std::shared_ptr< StateSequenceErrorFunctiond > |
| |
| using | StateSequenceErrorFunctiond_u = ::std::unique_ptr< StateSequenceErrorFunctiond > |
| |
| using | StateSequenceErrorFunctiond_w = ::std::weak_ptr< StateSequenceErrorFunctiond > |
| |
| using | StateSequenceErrorFunctiond_const_p = ::std::shared_ptr< const StateSequenceErrorFunctiond > |
| |
| using | StateSequenceErrorFunctiond_const_u = ::std::unique_ptr< const StateSequenceErrorFunctiond > |
| |
| using | StateSequenceErrorFunctiond_const_w = ::std::weak_ptr< const StateSequenceErrorFunctiond > |
| |
| using | VertexSequenceErrorFunction = VertexSequenceErrorFunctionT< float > |
| |
| using | VertexSequenceErrorFunctiond = VertexSequenceErrorFunctionT< double > |
| |
| using | VertexSequenceErrorFunction_p = ::std::shared_ptr< VertexSequenceErrorFunction > |
| |
| using | VertexSequenceErrorFunction_u = ::std::unique_ptr< VertexSequenceErrorFunction > |
| |
| using | VertexSequenceErrorFunction_w = ::std::weak_ptr< VertexSequenceErrorFunction > |
| |
| using | VertexSequenceErrorFunction_const_p = ::std::shared_ptr< const VertexSequenceErrorFunction > |
| |
| using | VertexSequenceErrorFunction_const_u = ::std::unique_ptr< const VertexSequenceErrorFunction > |
| |
| using | VertexSequenceErrorFunction_const_w = ::std::weak_ptr< const VertexSequenceErrorFunction > |
| |
| using | VertexSequenceErrorFunctiond_p = ::std::shared_ptr< VertexSequenceErrorFunctiond > |
| |
| using | VertexSequenceErrorFunctiond_u = ::std::unique_ptr< VertexSequenceErrorFunctiond > |
| |
| using | VertexSequenceErrorFunctiond_w = ::std::weak_ptr< VertexSequenceErrorFunctiond > |
| |
| using | VertexSequenceErrorFunctiond_const_p = ::std::shared_ptr< const VertexSequenceErrorFunctiond > |
| |
| using | VertexSequenceErrorFunctiond_const_u = ::std::unique_ptr< const VertexSequenceErrorFunctiond > |
| |
| using | VertexSequenceErrorFunctiond_const_w = ::std::weak_ptr< const VertexSequenceErrorFunctiond > |
| |
| using | ErrorFunctionDerivatives = ErrorFunctionDerivativesT< float > |
| |
| using | ErrorFunctionDerivativesd = ErrorFunctionDerivativesT< double > |
| |
| using | ErrorFunctionDerivatives_p = ::std::shared_ptr< ErrorFunctionDerivatives > |
| |
| using | ErrorFunctionDerivatives_u = ::std::unique_ptr< ErrorFunctionDerivatives > |
| |
| using | ErrorFunctionDerivatives_w = ::std::weak_ptr< ErrorFunctionDerivatives > |
| |
| using | ErrorFunctionDerivatives_const_p = ::std::shared_ptr< const ErrorFunctionDerivatives > |
| |
| using | ErrorFunctionDerivatives_const_u = ::std::unique_ptr< const ErrorFunctionDerivatives > |
| |
| using | ErrorFunctionDerivatives_const_w = ::std::weak_ptr< const ErrorFunctionDerivatives > |
| |
| using | ErrorFunctionDerivativesd_p = ::std::shared_ptr< ErrorFunctionDerivativesd > |
| |
| using | ErrorFunctionDerivativesd_u = ::std::unique_ptr< ErrorFunctionDerivativesd > |
| |
| using | ErrorFunctionDerivativesd_w = ::std::weak_ptr< ErrorFunctionDerivativesd > |
| |
| using | ErrorFunctionDerivativesd_const_p = ::std::shared_ptr< const ErrorFunctionDerivativesd > |
| |
| using | ErrorFunctionDerivativesd_const_u = ::std::unique_ptr< const ErrorFunctionDerivativesd > |
| |
| using | ErrorFunctionDerivativesd_const_w = ::std::weak_ptr< const ErrorFunctionDerivativesd > |
| |
| using | OrientationConstraint = OrientationConstraintT< float > |
| |
| using | OrientationConstraintd = OrientationConstraintT< double > |
| |
| using | OrientationConstraint_p = ::std::shared_ptr< OrientationConstraint > |
| |
| using | OrientationConstraint_u = ::std::unique_ptr< OrientationConstraint > |
| |
| using | OrientationConstraint_w = ::std::weak_ptr< OrientationConstraint > |
| |
| using | OrientationConstraint_const_p = ::std::shared_ptr< const OrientationConstraint > |
| |
| using | OrientationConstraint_const_u = ::std::unique_ptr< const OrientationConstraint > |
| |
| using | OrientationConstraint_const_w = ::std::weak_ptr< const OrientationConstraint > |
| |
| using | OrientationConstraintd_p = ::std::shared_ptr< OrientationConstraintd > |
| |
| using | OrientationConstraintd_u = ::std::unique_ptr< OrientationConstraintd > |
| |
| using | OrientationConstraintd_w = ::std::weak_ptr< OrientationConstraintd > |
| |
| using | OrientationConstraintd_const_p = ::std::shared_ptr< const OrientationConstraintd > |
| |
| using | OrientationConstraintd_const_u = ::std::unique_ptr< const OrientationConstraintd > |
| |
| using | OrientationConstraintd_const_w = ::std::weak_ptr< const OrientationConstraintd > |
| |
| using | OrientationConstraintState = OrientationConstraintStateT< float > |
| |
| using | OrientationConstraintStated = OrientationConstraintStateT< double > |
| |
| using | OrientationConstraintState_p = ::std::shared_ptr< OrientationConstraintState > |
| |
| using | OrientationConstraintState_u = ::std::unique_ptr< OrientationConstraintState > |
| |
| using | OrientationConstraintState_w = ::std::weak_ptr< OrientationConstraintState > |
| |
| using | OrientationConstraintState_const_p = ::std::shared_ptr< const OrientationConstraintState > |
| |
| using | OrientationConstraintState_const_u = ::std::unique_ptr< const OrientationConstraintState > |
| |
| using | OrientationConstraintState_const_w = ::std::weak_ptr< const OrientationConstraintState > |
| |
| using | OrientationConstraintStated_p = ::std::shared_ptr< OrientationConstraintStated > |
| |
| using | OrientationConstraintStated_u = ::std::unique_ptr< OrientationConstraintStated > |
| |
| using | OrientationConstraintStated_w = ::std::weak_ptr< OrientationConstraintStated > |
| |
| using | OrientationConstraintStated_const_p = ::std::shared_ptr< const OrientationConstraintStated > |
| |
| using | OrientationConstraintStated_const_u = ::std::unique_ptr< const OrientationConstraintStated > |
| |
| using | OrientationConstraintStated_const_w = ::std::weak_ptr< const OrientationConstraintStated > |
| |
| using | PositionConstraint = PositionConstraintT< float > |
| |
| using | PositionConstraintd = PositionConstraintT< double > |
| |
| using | PositionConstraint_p = ::std::shared_ptr< PositionConstraint > |
| |
| using | PositionConstraint_u = ::std::unique_ptr< PositionConstraint > |
| |
| using | PositionConstraint_w = ::std::weak_ptr< PositionConstraint > |
| |
| using | PositionConstraint_const_p = ::std::shared_ptr< const PositionConstraint > |
| |
| using | PositionConstraint_const_u = ::std::unique_ptr< const PositionConstraint > |
| |
| using | PositionConstraint_const_w = ::std::weak_ptr< const PositionConstraint > |
| |
| using | PositionConstraintd_p = ::std::shared_ptr< PositionConstraintd > |
| |
| using | PositionConstraintd_u = ::std::unique_ptr< PositionConstraintd > |
| |
| using | PositionConstraintd_w = ::std::weak_ptr< PositionConstraintd > |
| |
| using | PositionConstraintd_const_p = ::std::shared_ptr< const PositionConstraintd > |
| |
| using | PositionConstraintd_const_u = ::std::unique_ptr< const PositionConstraintd > |
| |
| using | PositionConstraintd_const_w = ::std::weak_ptr< const PositionConstraintd > |
| |
| using | PositionConstraintState = PositionConstraintStateT< float > |
| |
| using | PositionConstraintStated = PositionConstraintStateT< double > |
| |
| using | PositionConstraintState_p = ::std::shared_ptr< PositionConstraintState > |
| |
| using | PositionConstraintState_u = ::std::unique_ptr< PositionConstraintState > |
| |
| using | PositionConstraintState_w = ::std::weak_ptr< PositionConstraintState > |
| |
| using | PositionConstraintState_const_p = ::std::shared_ptr< const PositionConstraintState > |
| |
| using | PositionConstraintState_const_u = ::std::unique_ptr< const PositionConstraintState > |
| |
| using | PositionConstraintState_const_w = ::std::weak_ptr< const PositionConstraintState > |
| |
| using | PositionConstraintStated_p = ::std::shared_ptr< PositionConstraintStated > |
| |
| using | PositionConstraintStated_u = ::std::unique_ptr< PositionConstraintStated > |
| |
| using | PositionConstraintStated_w = ::std::weak_ptr< PositionConstraintStated > |
| |
| using | PositionConstraintStated_const_p = ::std::shared_ptr< const PositionConstraintStated > |
| |
| using | PositionConstraintStated_const_u = ::std::unique_ptr< const PositionConstraintStated > |
| |
| using | PositionConstraintStated_const_w = ::std::weak_ptr< const PositionConstraintStated > |
| |
| using | FullyDifferentiableDistanceErrorFunction = FullyDifferentiableDistanceErrorFunctionT< float > |
| |
| using | FullyDifferentiableDistanceErrorFunctiond = FullyDifferentiableDistanceErrorFunctionT< double > |
| |
| using | FullyDifferentiableDistanceErrorFunction_p = ::std::shared_ptr< FullyDifferentiableDistanceErrorFunction > |
| |
| using | FullyDifferentiableDistanceErrorFunction_u = ::std::unique_ptr< FullyDifferentiableDistanceErrorFunction > |
| |
| using | FullyDifferentiableDistanceErrorFunction_w = ::std::weak_ptr< FullyDifferentiableDistanceErrorFunction > |
| |
| using | FullyDifferentiableDistanceErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableDistanceErrorFunction > |
| |
| using | FullyDifferentiableDistanceErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableDistanceErrorFunction > |
| |
| using | FullyDifferentiableDistanceErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableDistanceErrorFunction > |
| |
| using | FullyDifferentiableDistanceErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableDistanceErrorFunctiond > |
| |
| using | FullyDifferentiableDistanceErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableDistanceErrorFunctiond > |
| |
| using | FullyDifferentiableDistanceErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableDistanceErrorFunctiond > |
| |
| using | FullyDifferentiableDistanceErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableDistanceErrorFunctiond > |
| |
| using | FullyDifferentiableDistanceErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableDistanceErrorFunctiond > |
| |
| using | FullyDifferentiableDistanceErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableDistanceErrorFunctiond > |
| |
| using | FullyDifferentiableMotionErrorFunction = FullyDifferentiableMotionErrorFunctionT< float > |
| |
| using | FullyDifferentiableMotionErrorFunctiond = FullyDifferentiableMotionErrorFunctionT< double > |
| |
| using | FullyDifferentiableMotionErrorFunction_p = ::std::shared_ptr< FullyDifferentiableMotionErrorFunction > |
| |
| using | FullyDifferentiableMotionErrorFunction_u = ::std::unique_ptr< FullyDifferentiableMotionErrorFunction > |
| |
| using | FullyDifferentiableMotionErrorFunction_w = ::std::weak_ptr< FullyDifferentiableMotionErrorFunction > |
| |
| using | FullyDifferentiableMotionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableMotionErrorFunction > |
| |
| using | FullyDifferentiableMotionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableMotionErrorFunction > |
| |
| using | FullyDifferentiableMotionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableMotionErrorFunction > |
| |
| using | FullyDifferentiableMotionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableMotionErrorFunctiond > |
| |
| using | FullyDifferentiableMotionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableMotionErrorFunctiond > |
| |
| using | FullyDifferentiableMotionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableMotionErrorFunctiond > |
| |
| using | FullyDifferentiableMotionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableMotionErrorFunctiond > |
| |
| using | FullyDifferentiableMotionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableMotionErrorFunctiond > |
| |
| using | FullyDifferentiableMotionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableMotionErrorFunctiond > |
| |
| using | FullyDifferentiableOrientationErrorFunction = FullyDifferentiableOrientationErrorFunctionT< float > |
| |
| using | FullyDifferentiableOrientationErrorFunctiond = FullyDifferentiableOrientationErrorFunctionT< double > |
| |
| using | FullyDifferentiableOrientationErrorFunction_p = ::std::shared_ptr< FullyDifferentiableOrientationErrorFunction > |
| |
| using | FullyDifferentiableOrientationErrorFunction_u = ::std::unique_ptr< FullyDifferentiableOrientationErrorFunction > |
| |
| using | FullyDifferentiableOrientationErrorFunction_w = ::std::weak_ptr< FullyDifferentiableOrientationErrorFunction > |
| |
| using | FullyDifferentiableOrientationErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableOrientationErrorFunction > |
| |
| using | FullyDifferentiableOrientationErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableOrientationErrorFunction > |
| |
| using | FullyDifferentiableOrientationErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableOrientationErrorFunction > |
| |
| using | FullyDifferentiableOrientationErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableOrientationErrorFunctiond > |
| |
| using | FullyDifferentiableOrientationErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableOrientationErrorFunctiond > |
| |
| using | FullyDifferentiableOrientationErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableOrientationErrorFunctiond > |
| |
| using | FullyDifferentiableOrientationErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableOrientationErrorFunctiond > |
| |
| using | FullyDifferentiableOrientationErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableOrientationErrorFunctiond > |
| |
| using | FullyDifferentiableOrientationErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableOrientationErrorFunctiond > |
| |
| using | FullyDifferentiablePosePriorErrorFunction = FullyDifferentiablePosePriorErrorFunctionT< float > |
| |
| using | FullyDifferentiablePosePriorErrorFunctiond = FullyDifferentiablePosePriorErrorFunctionT< double > |
| |
| using | FullyDifferentiablePosePriorErrorFunction_p = ::std::shared_ptr< FullyDifferentiablePosePriorErrorFunction > |
| |
| using | FullyDifferentiablePosePriorErrorFunction_u = ::std::unique_ptr< FullyDifferentiablePosePriorErrorFunction > |
| |
| using | FullyDifferentiablePosePriorErrorFunction_w = ::std::weak_ptr< FullyDifferentiablePosePriorErrorFunction > |
| |
| using | FullyDifferentiablePosePriorErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiablePosePriorErrorFunction > |
| |
| using | FullyDifferentiablePosePriorErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiablePosePriorErrorFunction > |
| |
| using | FullyDifferentiablePosePriorErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiablePosePriorErrorFunction > |
| |
| using | FullyDifferentiablePosePriorErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiablePosePriorErrorFunctiond > |
| |
| using | FullyDifferentiablePosePriorErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiablePosePriorErrorFunctiond > |
| |
| using | FullyDifferentiablePosePriorErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiablePosePriorErrorFunctiond > |
| |
| using | FullyDifferentiablePosePriorErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiablePosePriorErrorFunctiond > |
| |
| using | FullyDifferentiablePosePriorErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiablePosePriorErrorFunctiond > |
| |
| using | FullyDifferentiablePosePriorErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiablePosePriorErrorFunctiond > |
| |
| using | FullyDifferentiablePositionErrorFunction = FullyDifferentiablePositionErrorFunctionT< float > |
| |
| using | FullyDifferentiablePositionErrorFunctiond = FullyDifferentiablePositionErrorFunctionT< double > |
| |
| using | FullyDifferentiablePositionErrorFunction_p = ::std::shared_ptr< FullyDifferentiablePositionErrorFunction > |
| |
| using | FullyDifferentiablePositionErrorFunction_u = ::std::unique_ptr< FullyDifferentiablePositionErrorFunction > |
| |
| using | FullyDifferentiablePositionErrorFunction_w = ::std::weak_ptr< FullyDifferentiablePositionErrorFunction > |
| |
| using | FullyDifferentiablePositionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiablePositionErrorFunction > |
| |
| using | FullyDifferentiablePositionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiablePositionErrorFunction > |
| |
| using | FullyDifferentiablePositionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiablePositionErrorFunction > |
| |
| using | FullyDifferentiablePositionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiablePositionErrorFunctiond > |
| |
| using | FullyDifferentiablePositionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiablePositionErrorFunctiond > |
| |
| using | FullyDifferentiablePositionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiablePositionErrorFunctiond > |
| |
| using | FullyDifferentiablePositionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiablePositionErrorFunctiond > |
| |
| using | FullyDifferentiablePositionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiablePositionErrorFunctiond > |
| |
| using | FullyDifferentiablePositionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiablePositionErrorFunctiond > |
| |
| using | FullyDifferentiableProjectionErrorFunction = FullyDifferentiableProjectionErrorFunctionT< float > |
| |
| using | FullyDifferentiableProjectionErrorFunctiond = FullyDifferentiableProjectionErrorFunctionT< double > |
| |
| using | FullyDifferentiableProjectionErrorFunction_p = ::std::shared_ptr< FullyDifferentiableProjectionErrorFunction > |
| |
| using | FullyDifferentiableProjectionErrorFunction_u = ::std::unique_ptr< FullyDifferentiableProjectionErrorFunction > |
| |
| using | FullyDifferentiableProjectionErrorFunction_w = ::std::weak_ptr< FullyDifferentiableProjectionErrorFunction > |
| |
| using | FullyDifferentiableProjectionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableProjectionErrorFunction > |
| |
| using | FullyDifferentiableProjectionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableProjectionErrorFunction > |
| |
| using | FullyDifferentiableProjectionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableProjectionErrorFunction > |
| |
| using | FullyDifferentiableProjectionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableProjectionErrorFunctiond > |
| |
| using | FullyDifferentiableProjectionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableProjectionErrorFunctiond > |
| |
| using | FullyDifferentiableProjectionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableProjectionErrorFunctiond > |
| |
| using | FullyDifferentiableProjectionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableProjectionErrorFunctiond > |
| |
| using | FullyDifferentiableProjectionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableProjectionErrorFunctiond > |
| |
| using | FullyDifferentiableProjectionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableProjectionErrorFunctiond > |
| |
| using | FullyDifferentiableSkeletonErrorFunction = FullyDifferentiableSkeletonErrorFunctionT< float > |
| |
| using | FullyDifferentiableSkeletonErrorFunctiond = FullyDifferentiableSkeletonErrorFunctionT< double > |
| |
| using | FullyDifferentiableSkeletonErrorFunction_p = ::std::shared_ptr< FullyDifferentiableSkeletonErrorFunction > |
| |
| using | FullyDifferentiableSkeletonErrorFunction_u = ::std::unique_ptr< FullyDifferentiableSkeletonErrorFunction > |
| |
| using | FullyDifferentiableSkeletonErrorFunction_w = ::std::weak_ptr< FullyDifferentiableSkeletonErrorFunction > |
| |
| using | FullyDifferentiableSkeletonErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableSkeletonErrorFunction > |
| |
| using | FullyDifferentiableSkeletonErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableSkeletonErrorFunction > |
| |
| using | FullyDifferentiableSkeletonErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableSkeletonErrorFunction > |
| |
| using | FullyDifferentiableSkeletonErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableSkeletonErrorFunctiond > |
| |
| using | FullyDifferentiableSkeletonErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableSkeletonErrorFunctiond > |
| |
| using | FullyDifferentiableSkeletonErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableSkeletonErrorFunctiond > |
| |
| using | FullyDifferentiableSkeletonErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableSkeletonErrorFunctiond > |
| |
| using | FullyDifferentiableSkeletonErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableSkeletonErrorFunctiond > |
| |
| using | FullyDifferentiableSkeletonErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableSkeletonErrorFunctiond > |
| |
| using | FullyDifferentiableStateErrorFunction = FullyDifferentiableStateErrorFunctionT< float > |
| |
| using | FullyDifferentiableStateErrorFunctiond = FullyDifferentiableStateErrorFunctionT< double > |
| |
| using | FullyDifferentiableStateErrorFunction_p = ::std::shared_ptr< FullyDifferentiableStateErrorFunction > |
| |
| using | FullyDifferentiableStateErrorFunction_u = ::std::unique_ptr< FullyDifferentiableStateErrorFunction > |
| |
| using | FullyDifferentiableStateErrorFunction_w = ::std::weak_ptr< FullyDifferentiableStateErrorFunction > |
| |
| using | FullyDifferentiableStateErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableStateErrorFunction > |
| |
| using | FullyDifferentiableStateErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableStateErrorFunction > |
| |
| using | FullyDifferentiableStateErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableStateErrorFunction > |
| |
| using | FullyDifferentiableStateErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableStateErrorFunctiond > |
| |
| using | FullyDifferentiableStateErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableStateErrorFunctiond > |
| |
| using | FullyDifferentiableStateErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableStateErrorFunctiond > |
| |
| using | FullyDifferentiableStateErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableStateErrorFunctiond > |
| |
| using | FullyDifferentiableStateErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableStateErrorFunctiond > |
| |
| using | FullyDifferentiableStateErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableStateErrorFunctiond > |
| |
| using | UnionErrorFunction = UnionErrorFunctionT< float > |
| |
| using | UnionErrorFunctiond = UnionErrorFunctionT< double > |
| |
| using | UnionErrorFunction_p = ::std::shared_ptr< UnionErrorFunction > |
| |
| using | UnionErrorFunction_u = ::std::unique_ptr< UnionErrorFunction > |
| |
| using | UnionErrorFunction_w = ::std::weak_ptr< UnionErrorFunction > |
| |
| using | UnionErrorFunction_const_p = ::std::shared_ptr< const UnionErrorFunction > |
| |
| using | UnionErrorFunction_const_u = ::std::unique_ptr< const UnionErrorFunction > |
| |
| using | UnionErrorFunction_const_w = ::std::weak_ptr< const UnionErrorFunction > |
| |
| using | UnionErrorFunctiond_p = ::std::shared_ptr< UnionErrorFunctiond > |
| |
| using | UnionErrorFunctiond_u = ::std::unique_ptr< UnionErrorFunctiond > |
| |
| using | UnionErrorFunctiond_w = ::std::weak_ptr< UnionErrorFunctiond > |
| |
| using | UnionErrorFunctiond_const_p = ::std::shared_ptr< const UnionErrorFunctiond > |
| |
| using | UnionErrorFunctiond_const_u = ::std::unique_ptr< const UnionErrorFunctiond > |
| |
| using | UnionErrorFunctiond_const_w = ::std::weak_ptr< const UnionErrorFunctiond > |
| |
|
| void * | aligned_malloc (size_t size, size_t align) |
| |
| void | aligned_free (void *ptr) |
| |
| constexpr std::size_t | roundUpToAlignment (std::size_t value, std::size_t alignment) |
| |
| template<typename T , std::size_t Alignment = alignof(T)> |
| T * | alignedAlloc (std::size_t n) |
| | Allocates a block of memory that can hold n elements of type T with the specified alignment.
|
| |
| template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter> |
| std::unique_ptr< T, Deleter > | makeAlignedUnique (std::size_t n, Deleter deleter=Deleter()) |
| | Creates a std::unique_ptr for aligned memory.
|
| |
| template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter> |
| std::shared_ptr< T > | makeAlignedShared (std::size_t n, Deleter deleter=Deleter()) |
| | Creates a std::shared_ptr for aligned memory.
|
| |
| template<class T , class U , std::size_t Alignment> |
| bool | operator== (const AlignedAllocator< T, Alignment > &, const AlignedAllocator< U, Alignment > &) |
| | Checks if storage allocated from lhs can be deallocated from rhs, and vice versa.
|
| |
| template<class T , class U , std::size_t Alignment> |
| bool | operator!= (const AlignedAllocator< T, Alignment > &, const AlignedAllocator< U, Alignment > &) |
| | Checks if storage allocated from lhs cannot be deallocated from rhs, and vice versa.
|
| |
| std::map< std::string, LogLevel > | logLevelMap () |
| |
| void | setLogLevel (LogLevel level) |
| |
| void | setLogLevel (const std::string &levelStr) |
| |
| LogLevel | getLogLevel () |
| |
| template<typename StringType > |
| StringType | trim (const StringType &text, const char *whiteChars=" \t") |
| | Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.
|
| |
| template std::string | trim (const std::string &text, const char *whiteChars) |
| |
| template std::string_view | trim (const std::string_view &text, const char *whiteChars) |
| |
| std::string | trim (const char *text, const char *whiteChars=" \t") |
| | Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.
|
| |
| std::vector< std::string > | tokenize (const std::string &inputString, const std::string &delimiters=" \t\r\n", bool trim=true) |
| | Tokenize a string using the specified delimiters.
|
| |
| std::vector< std::string_view > | tokenize (std::string_view inputString, std::string_view delimiters=" \t\r\n", bool trim=true) |
| | Tokenize a string_view using the specified delimiters.
|
| |
| template<size_t Alignment> |
| size_t | computeOffset (const Eigen::Ref< Eigen::MatrixXf > &mat) |
| | Computes the offset required for the matrix data to meet the alignment requirement.
|
| |
| template<size_t Alignment> |
| void | checkAlignment (const Eigen::Ref< Eigen::MatrixXf > &mat, size_t offset=0) |
| | Checks if the data of the matrix is aligned correctly.
|
| |
| template<typename Derived , typename S > |
| FloatP | dot (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2) |
| | Calculates dot product of Eigen::Vector3f and 3-vector of packets.
|
| |
| template<typename Derived , typename S > |
| FloatP | dot (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2) |
| | Calculates dot product of Vector3P and Eigen::Vector3f.
|
| |
| template<typename S , typename Derived > |
| Vector3P< S > | operator+ (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2) |
| | Calculates summation of Eigen::Vector3f and Vector3P.
|
| |
| template<typename S , typename Derived > |
| Vector3P< S > | operator+ (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2) |
| | Calculates summation of Vector3P and Eigen::Vector3f.
|
| |
| template<typename S , typename Derived > |
| Vector3P< S > | operator- (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2) |
| | Calculates subtraction of Eigen::Vector3f and Vector3P.
|
| |
| template<typename S , typename Derived > |
| Vector3P< S > | operator- (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2) |
| | Calculates subtraction of Vector3P and Eigen::Vector3f.
|
| |
| template<typename S > |
| Vector3P< S > | operator* (const Eigen::Quaternion< S > &q, const Vector3P< S > &vec) |
| | Calculates multiplication of quaternion and each 3x1 vector in packet.
|
| |
| template<typename S , typename Derived > |
| Vector3P< S > | operator* (const Eigen::MatrixBase< Derived > &xf, const Vector3P< S > &vec) |
| | Calculates multiplication of 3x3 matrix and each 3x1 vector in packet.
|
| |
| template<typename S > |
| Vector3P< S > | operator* (const Eigen::Transform< S, 3, Eigen::Affine > &xf, const Vector3P< S > &vec) |
| | Calculates affine transformation on each 3x1 vector in packet.
|
| |
| template<typename S > |
| Vector3P< S > | operator* (const TransformT< S > &xf, const Vector3P< S > &vec) |
| | Calculates transformation on each 3x1 vector in packet using momentum::Transform.
|
| |
| template<typename S , typename Derived > |
| Vector3P< S > | cross (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2) |
| | Calculates cross product of Eigen::Vector3f and Vector3P.
|
| |
| template<typename S , typename Derived > |
| Vector3P< S > | cross (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2) |
| | Calculates cross product of Vector3P and Eigen::Vector3f.
|
| |
| template<typename T = float> |
| constexpr T | nan () noexcept |
| |
| template<typename T > |
| constexpr T | Eps (T FloatEps=T(1e-7), T DoubleEps=T(1e-16)) |
| | Returns the tolerance value based on the provided type T.
|
| |
| template<typename T = float> |
| constexpr T | ln2 () noexcept |
| |
| template<typename T = float> |
| constexpr T | pi () noexcept |
| |
| template<typename T = float> |
| constexpr T | twopi () noexcept |
| |
| template<typename T = float> |
| constexpr T | toRad (T x=T(1)) noexcept |
| | Converts the given angle x (in degrees) to radians.
|
| |
| template<typename T = float> |
| constexpr T | toDeg (T x=T(1)) noexcept |
| | Converts the given angle x (in radians) to degrees.
|
| |
| template<typename T = float> |
| constexpr T | toM (T x=T(1)) noexcept |
| | Converts the given length x (in centimeters) to meters.
|
| |
| template<typename T = float> |
| constexpr T | toCm (T x=T(1)) noexcept |
| | Converts the given length x (in meters) to centimeters.
|
| |
| template<typename T > |
| bool | intersectFace (const MeshT< T > &mesh, const std::vector< Vector3< T > > &faceNormals, int32_t face0, int32_t face1) |
| | test whether two given faces of a mesh intersect with each other
|
| |
| template<typename T > |
| std::vector< std::pair< int32_t, int32_t > > | intersectMeshBruteForce (const MeshT< T > &mesh) |
| | test if the mesh self intersects anywhere and return all intersecting face pairs using brute force
|
| |
| template<typename T > |
| std::vector< std::pair< int32_t, int32_t > > | intersectMesh (const MeshT< T > &mesh) |
| | test if the mesh self intersects anywhere and return all intersecting face pairs using a bvh tree
|
| |
| template bool | intersectFace< float > (const MeshT< float > &mesh, const std::vector< Vector3< float > > &faceNormals, const int32_t face0, const int32_t face1) |
| |
| template bool | intersectFace< double > (const MeshT< double > &mesh, const std::vector< Vector3< double > > &faceNormals, const int32_t face0, const int32_t face1) |
| |
| template std::vector< std::pair< int32_t, int32_t > > | intersectMeshBruteForce< float > (const MeshT< float > &mesh) |
| |
| template std::vector< std::pair< int32_t, int32_t > > | intersectMeshBruteForce< double > (const MeshT< double > &mesh) |
| |
| template std::vector< std::pair< int32_t, int32_t > > | intersectMesh< float > (const MeshT< float > &mesh) |
| |
| template std::vector< std::pair< int32_t, int32_t > > | intersectMesh< double > (const MeshT< double > &mesh) |
| |
| template<typename T , typename T2 , int N> |
| std::vector< Eigen::Vector< T2, N > > | castVectors (const std::vector< Eigen::Vector< T, N > > &vec_in) |
| |
| template<typename T , typename T2 > |
| std::vector< Eigen::MatrixX< T2 > > | castMatrices (std::span< const Eigen::MatrixX< T > > m_in) |
| |
| void | validateColumnIndices (std::span< const Eigen::Index > colIndices, Eigen::Index maxEntry) |
| |
| template<typename T > |
| T | uniform (const T &min, const T &max) |
| | Generates a random type T from the uniform distribution, using the global random number generator Random.
|
| |
| template<typename FixedSizeT > |
| FixedSizeT | uniform (typename FixedSizeT::Scalar min, typename FixedSizeT::Scalar max) |
| | Generates a random fixed size vector/matrix from the uniform distribution, using the global random number generator Random.
|
| |
| template<typename DynamicVector > |
| DynamicVector | uniform (Eigen::Index size, typename DynamicVector::Scalar min, typename DynamicVector::Scalar max) |
| | Generates a random dynamic size vector from the uniform distribution, using the global random number generator Random.
|
| |
| template<typename DynamicMatrix > |
| DynamicMatrix | uniform (Eigen::Index rows, Eigen::Index cols, typename DynamicMatrix::Scalar min, typename DynamicMatrix::Scalar max) |
| | Generates a random type dynamic size matrix from the uniform distribution, using the global random number generator Random.
|
| |
| template<typename T > |
| Quaternion< T > | uniformQuaternion () |
| | Generates a random quaternion from a uniform distribution on SO(3)
|
| |
| template<typename T > |
| Matrix3< T > | uniformRotationMatrix () |
| | Generates a random rotation matrix from a uniform distribution on SO(3)
|
| |
| template<typename T > |
| Isometry3< T > | uniformIsometry3 (const Vector3< T > &min=Vector3< T >::Zero(), const Vector3< T > &max=Vector3< T >::Ones()) |
| | Generates a random isometry (rigid transformation) from a uniform distribution on SE(3) based on input minimum and maximum 3D vectors for the translation part.
|
| |
| template<typename T > |
| Affine3< T > | uniformAffine3 (T scaleMin=0.1, T scaleMax=10.0, const Vector3< T > &min=Vector3< T >::Zero(), const Vector3< T > &max=Vector3< T >::Ones()) |
| | Generates a random affine transformation from a uniform distribution on the space of all affine transformations.
|
| |
| template<typename T > |
| T | normal (const T &mean, const T &sigma) |
| | Generates a random type T from the Gaussian distribution, using the global random number generator Random.
|
| |
| template<typename FixedSizeT > |
| FixedSizeT | normal (typename FixedSizeT::Scalar mean, typename FixedSizeT::Scalar sigma) |
| | Generates a random fixed size vector/matrix from the Gaussian distribution, using the global random number generator Random.
|
| |
| template<typename DynamicVector > |
| DynamicVector | normal (Eigen::Index size, typename DynamicVector::Scalar mean, typename DynamicVector::Scalar sigma) |
| | Generates a random dynamic size vector from the Gaussian distribution, using the global random number generator Random.
|
| |
| template<typename DynamicMatrix > |
| DynamicMatrix | normal (Eigen::Index rows, Eigen::Index cols, typename DynamicMatrix::Scalar mean, typename DynamicMatrix::Scalar sigma) |
| | Generates a random dynamic size matrix from the Gaussian distribution, using the global random number generator Random.
|
| |
| template<typename T > |
| TransformT< T > | blendTransforms (std::span< const TransformT< T > > transforms, std::span< const T > weights) |
| |
| template<typename T > |
| TransformT< T > | slerp (const TransformT< T > &t1, const TransformT< T > &t2, T weight) |
| | Spherical linear interpolation between two transforms.
|
| |
| template TransformT< float > | blendTransforms (std::span< const TransformT< float > > transforms, std::span< const float > weights) |
| |
| template TransformT< double > | blendTransforms (std::span< const TransformT< double > > transforms, std::span< const double > weights) |
| |
| template TransformT< float > | slerp (const TransformT< float > &, const TransformT< float > &, float) |
| |
| template TransformT< double > | slerp (const TransformT< double > &, const TransformT< double > &, double) |
| |
| template<typename OtherScalar , template< typename... > class ContainerType, typename ObjectType > |
| decltype(auto) | cast (const ContainerType< ObjectType > &originalContainer) |
| | Casts the scalar type of objects in a container that support the cast<>() method.
|
| |
| template MatrixX< float > | pseudoInverse (const MatrixX< float > &mat) |
| |
| template MatrixX< double > | pseudoInverse (const MatrixX< double > &mat) |
| |
| template MatrixX< float > | pseudoInverse (const SparseMatrix< float > &mat) |
| |
| template MatrixX< double > | pseudoInverse (const SparseMatrix< double > &mat) |
| |
| template Quaternion< float > | quaternionExpMap (const Vector3< float > &v) |
| |
| template Quaternion< double > | quaternionExpMap (const Vector3< double > &v) |
| |
| template Vector3< float > | quaternionLogMap (const Quaternion< float > &q) |
| |
| template Vector3< double > | quaternionLogMap (const Quaternion< double > &q) |
| |
| template Eigen::Matrix< float, 3, 4 > | quaternionLogMapDerivative (const Quaternion< float > &q) |
| |
| template Eigen::Matrix< double, 3, 4 > | quaternionLogMapDerivative (const Quaternion< double > &q) |
| |
| template Vector3< float > | rotationMatrixToEuler (const Matrix3< float > &m, int axis0, int axis1, int axis2, EulerConvention convention) |
| |
| template Vector3< double > | rotationMatrixToEuler (const Matrix3< double > &m, int axis0, int axis1, int axis2, EulerConvention convention) |
| |
| template Vector3< float > | rotationMatrixToEulerXYZ (const Matrix3< float > &m, EulerConvention convention) |
| |
| template Vector3< double > | rotationMatrixToEulerXYZ (const Matrix3< double > &m, EulerConvention convention) |
| |
| template Vector3< float > | rotationMatrixToEulerZYX (const Matrix3< float > &m, EulerConvention convention) |
| |
| template Vector3< double > | rotationMatrixToEulerZYX (const Matrix3< double > &m, EulerConvention convention) |
| |
| template Quaternion< float > | eulerToQuaternion (const Vector3< float > &angles, int axis0, int axis1, int axis2, EulerConvention convention) |
| |
| template Quaternion< double > | eulerToQuaternion (const Vector3< double > &angles, int axis0, int axis1, int axis2, EulerConvention convention) |
| |
| template Matrix3< float > | eulerToRotationMatrix (const Vector3< float > &angles, int axis0, int axis1, int axis2, EulerConvention convention) |
| |
| template Matrix3< double > | eulerToRotationMatrix (const Vector3< double > &angles, int axis0, int axis1, int axis2, EulerConvention convention) |
| |
| template Matrix3< float > | eulerXYZToRotationMatrix (const Vector3< float > &angles, EulerConvention convention) |
| |
| template Matrix3< double > | eulerXYZToRotationMatrix (const Vector3< double > &angles, EulerConvention convention) |
| |
| template Matrix3< float > | eulerZYXToRotationMatrix (const Vector3< float > &angles, EulerConvention convention) |
| |
| template Matrix3< double > | eulerZYXToRotationMatrix (const Vector3< double > &angles, EulerConvention convention) |
| |
| template Vector3f | quaternionToEuler (const Quaternionf &q) |
| |
| template Vector3d | quaternionToEuler (const Quaterniond &q) |
| |
| template std::tuple< bool, float, Eigen::Vector2< float > > | closestPointsOnSegments< float > (const Eigen::Vector3< float > &o1, const Eigen::Vector3< float > &d1, const Eigen::Vector3< float > &o2, const Eigen::Vector3< float > &d2, const float maxDist) |
| |
| template std::tuple< bool, double, Eigen::Vector2< double > > | closestPointsOnSegments< double > (const Eigen::Vector3< double > &o1, const Eigen::Vector3< double > &d1, const Eigen::Vector3< double > &o2, const Eigen::Vector3< double > &d2, const double maxDist) |
| |
| template float | rotationMatrixToOneAxisEuler (const Matrix3< float > &m, int axis0) |
| |
| template double | rotationMatrixToOneAxisEuler (const Matrix3< double > &m, int axis0) |
| |
| template Vector2< float > | rotationMatrixToTwoAxisEuler (const Matrix3< float > &m, int axis0, int axis1) |
| |
| template Vector2< double > | rotationMatrixToTwoAxisEuler (const Matrix3< double > &m, int axis0, int axis1) |
| |
| bool | IsNanNoOpt (float f) |
| | NaN check function that isn't optimized away by fastmath.
|
| |
| template<typename T > |
| BlendWeightsT< T > | extractBlendWeights (const ParameterTransform ¶mTransform, const ModelParametersT< T > &modelParams) |
| | Extracts blend shape weights from model parameters.
|
| |
| template<typename T > |
| BlendWeightsT< T > | extractFaceExpressionBlendWeights (const ParameterTransform ¶mTransform, const ModelParametersT< T > &modelParams) |
| | Extracts facial expression blend shape weights from model parameters.
|
| |
| template<typename T > |
| void | skinWithBlendShapes (const Character &character, const SkeletonStateT< T > &state, const ModelParametersT< T > &modelParams, MeshT< T > &outputMesh) |
| | Applies blend shape deformations and skeletal transformations to a mesh.
|
| |
| template<typename T > |
| void | skinWithBlendShapes (const Character &character, const SkeletonStateT< T > &state, const BlendWeightsT< T > &blendWeights, MeshT< T > &outputMesh) |
| | Applies blend shape deformations and skeletal transformations to a mesh.
|
| |
| template void | skinWithBlendShapes (const Character &character, const SkeletonStateT< float > &state, const BlendWeightsT< float > &modelParams, MeshT< float > &outputMesh) |
| |
| template void | skinWithBlendShapes (const Character &character, const SkeletonStateT< double > &state, const BlendWeightsT< double > &modelParams, MeshT< double > &outputMesh) |
| |
| template void | skinWithBlendShapes (const Character &character, const SkeletonStateT< float > &state, const ModelParametersT< float > &modelParams, MeshT< float > &outputMesh) |
| |
| template void | skinWithBlendShapes (const Character &character, const SkeletonStateT< double > &state, const ModelParametersT< double > &modelParams, MeshT< double > &outputMesh) |
| |
| template BlendWeightsT< float > | extractBlendWeights< float > (const ParameterTransform ¶mTransform, const ModelParametersT< float > &modelParams) |
| |
| template BlendWeightsT< double > | extractBlendWeights< double > (const ParameterTransform ¶mTransform, const ModelParametersT< double > &modelParams) |
| |
| template BlendWeightsT< float > | extractFaceExpressionBlendWeights< float > (const ParameterTransform ¶mTransform, const ModelParametersT< float > &modelParams) |
| |
| template BlendWeightsT< double > | extractFaceExpressionBlendWeights< double > (const ParameterTransform ¶mTransform, const ModelParametersT< double > &modelParams) |
| |
| Character | scaleCharacter (const Character &character, float scale) |
| | Scales the character (mesh and skeleton) by the desired amount.
|
| |
| Character | transformCharacter (const Character &character, const Affine3f &xform) |
| | Transforms the character (mesh and skeleton) by the desired transformation matrix.
|
| |
| Character | replaceSkeletonHierarchy (const Character &srcCharacter, const Character &tgtCharacter, const std::string &srcRootJoint, const std::string &tgtRootJoint) |
| | Replaces the part of target_character's skeleton rooted at target_root with the part of source_character's skeleton rooted at source_root.
|
| |
| Character | removeJoints (const Character &character, std::span< const size_t > jointsToRemove) |
| | Removes the specified joints and any joints parented beneath them from the character.
|
| |
| MatrixXf | mapMotionToCharacter (const MotionParameters &inputMotion, const Character &targetCharacter) |
| | Maps the input ModelParameter motion to a target character by matching model parameter names.
|
| |
| VectorXf | mapIdentityToCharacter (const IdentityParameters &inputIdentity, const Character &targetCharacter) |
| | Maps the input JointParameter vector to a target character by matching joint names.
|
| |
| template<typename T > |
| CharacterT< T > | reduceMeshByVertices (const CharacterT< T > &character, const std::vector< bool > &activeVertices) |
| | Reduces the mesh to only include the specified vertices and associated faces.
|
| |
| template<typename T > |
| CharacterT< T > | reduceMeshByFaces (const CharacterT< T > &character, const std::vector< bool > &activeFaces) |
| | Reduces the mesh to only include the specified faces and associated vertices.
|
| |
| template<typename T > |
| std::vector< bool > | verticesToFaces (const MeshT< T > &mesh, const std::vector< bool > &activeVertices) |
| | Converts vertex selection to face selection.
|
| |
| template<typename T > |
| std::vector< bool > | facesToVertices (const MeshT< T > &mesh, const std::vector< bool > &activeFaces) |
| | Converts face selection to vertex selection.
|
| |
| template CharacterT< float > | reduceMeshByVertices< float > (const CharacterT< float > &character, const std::vector< bool > &activeVertices) |
| |
| template CharacterT< double > | reduceMeshByVertices< double > (const CharacterT< double > &character, const std::vector< bool > &activeVertices) |
| |
| template CharacterT< float > | reduceMeshByFaces< float > (const CharacterT< float > &character, const std::vector< bool > &activeFaces) |
| |
| template CharacterT< double > | reduceMeshByFaces< double > (const CharacterT< double > &character, const std::vector< bool > &activeFaces) |
| |
| template std::vector< bool > | verticesToFaces< float > (const MeshT< float > &mesh, const std::vector< bool > &activeVertices) |
| |
| template std::vector< bool > | verticesToFaces< double > (const MeshT< double > &mesh, const std::vector< bool > &activeVertices) |
| |
| template std::vector< bool > | facesToVertices< float > (const MeshT< float > &mesh, const std::vector< bool > &activeFaces) |
| |
| template std::vector< bool > | facesToVertices< double > (const MeshT< double > &mesh, const std::vector< bool > &activeFaces) |
| |
| template<typename T > |
| bool | overlaps (const Vector3< T > &originA, const Vector3< T > &directionA, const Vector2< T > &radiiA, T deltaA, const Vector3< T > &originB, const Vector3< T > &directionB, const Vector2< T > &radiiB, T deltaB, T &outDistance, Vector2< T > &outClosestPoints, T &outOverlap) |
| | Determines if two tapered capsules overlap.
|
| |
| template<typename T > |
| void | updateAabb (axel::BoundingBox< T > &aabb, const Vector3< T > &originA, const Vector3< T > &direction, const Vector2< T > &radii) |
| | Updates an axis-aligned bounding box to encompass a tapered capsule.
|
| |
| template<typename T > |
| Eigen::SparseMatrix< T > | toColumnMajor (const SparseRowMatrix< T > &mat) |
| |
| template<typename T > |
| std::vector< Vector3< T > > | applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< T > >::type points, const SkeletonStateT< T > &state) |
| | Applies forward SSD (linear blend skinning) to points, returning new points.
|
| |
| template<typename T > |
| void | applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, const SkeletonStateT< T > &state, MeshT< T > &outputMesh) |
| | Applies forward SSD to a mesh using skeleton state, modifying output mesh.
|
| |
| template<typename T > |
| void | applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, const JointStateListT< T > &state, MeshT< T > &outputMesh) |
| | Applies forward SSD to a mesh using raw joint state list, modifying output mesh.
|
| |
| Affine3f | getInverseSSDTransformation (const TransformationList &inverseBindPose, const SkinWeights &skin, const SkeletonState &state, size_t index) |
| | Computes the inverse SSD transformation for a specific vertex.
|
| |
| void | applyInverseSSD (const TransformationList &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const SkeletonState &state, Mesh &mesh) |
| | Applies inverse SSD to points, storing results in a mesh.
|
| |
| std::vector< Vector3f > | applyInverseSSD (const TransformationList &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const SkeletonState &state) |
| | Applies inverse SSD to points, returning new points in bind pose space.
|
| |
| template std::vector< Vector3f > | applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< float > >::type points, const SkeletonStateT< float > &state) |
| |
| template std::vector< Vector3d > | applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< double > >::type points, const SkeletonStateT< double > &state) |
| |
| template void | applySSD< float > (const TransformationList &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, const SkeletonStateT< float > &jointState, MeshT< float > &outputMesh) |
| |
| template void | applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, const SkeletonStateT< double > &jointState, MeshT< double > &outputMesh) |
| |
| template void | applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, const JointStateListT< float > &jointState, MeshT< float > &outputMesh) |
| |
| template void | applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, const JointStateListT< double > &jointState, MeshT< double > &outputMesh) |
| |
| std::string_view | toString (const LimitType type) |
| |
| JointParameters | applyPassiveJointParameterLimits (const ParameterLimits &limits, const JointParameters &jointParams) |
| | Only processes MinMaxJointPassive limits, clamping parameters to their ranges.
|
| |
| ParameterLimits | getPoseConstraintParameterLimits (const std::string &name, const ParameterTransform &pt, float weight=1.0f) |
| | Creates MinMax limits from a pose constraint.
|
| |
| bool | isInRange (const LimitLinear &limit, float value) |
| | If rangeMin and rangeMax are both 0, the limit applies to all values.
|
| |
| bool | isInRange (const LimitLinearJoint &limit, float value) |
| | If rangeMin and rangeMax are both 0, the limit applies to all values.
|
| |
| template<typename T > |
| ParameterTransformT< T > | mapParameterTransformJoints (const ParameterTransformT< T > ¶meterTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping) |
| | Construct a new parameter transform where the joints have been mapped to a new skeleton.
|
| |
| template<typename T > |
| std::tuple< ParameterTransformT< T >, ParameterLimits > | subsetParameterTransform (const ParameterTransformT< T > ¶mTransform, const ParameterLimits ¶mLimitsOld, const ParameterSet ¶mSet) |
| | Return a parameter mapping that only includes the listed parameters.
|
| |
| std::tuple< ParameterTransform, ParameterLimits > | addBlendShapeParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, Eigen::Index nBlendShapes) |
| |
| std::tuple< ParameterTransform, ParameterLimits > | addFaceExpressionParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, Eigen::Index nFaceExpressionBlendShapes) |
| |
| std::tuple< ParameterTransform, ParameterLimits > | addSkinnedLocatorParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, const std::vector< bool > &activeLocators, const std::vector< std::string > &locatorNames={}) |
| | Add a set of parameters that control the rest-space positions of the skinned locators.
|
| |
| template std::tuple< ParameterTransformT< float >, ParameterLimits > | subsetParameterTransform (const ParameterTransformT< float > ¶mTransform, const ParameterLimits ¶meterLimits, const ParameterSet ¶mSet) |
| |
| template std::tuple< ParameterTransformT< double >, ParameterLimits > | subsetParameterTransform (const ParameterTransformT< double > ¶mTransform, const ParameterLimits ¶meterLimits, const ParameterSet ¶mSet) |
| |
| template ParameterTransformT< float > | mapParameterTransformJoints (const ParameterTransformT< float > ¶mTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping) |
| |
| template ParameterTransformT< double > | mapParameterTransformJoints (const ParameterTransformT< double > ¶mTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping) |
| |
| template<typename T > |
| TransformT< T > | transformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< T > &skelState) |
| | Computes the relative transform between two joints in a skeleton.
|
| |
| template<typename T > |
| JointParametersT< T > | skeletonStateToJointParameters (const SkeletonStateT< T > &state, const Skeleton &skeleton) |
| | Invert the skeleton state (global transforms in world space) back to joint parameters (Euler angles in local space).
|
| |
| template<typename T > |
| JointParametersT< T > | skeletonStateToJointParameters (const TransformListT< T > &state, const Skeleton &skeleton) |
| |
| template<typename T > |
| JointParametersT< T > | skeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< T > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams) |
| | Converts skeleton state back to joint parameters, respecting active joint parameter constraints.
|
| |
| template<typename T > |
| JointParametersT< T > | skeletonStateToJointParametersRespectingActiveParameters (const TransformListT< T > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams) |
| | Converts transform list back to joint parameters, respecting active joint parameter constraints.
|
| |
| template TransformT< float > | transformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< float > &skelState) |
| |
| template TransformT< double > | transformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< double > &skelState) |
| |
| template JointParametersT< float > | skeletonStateToJointParameters (const SkeletonStateT< float > &state, const Skeleton &skeleton) |
| |
| template JointParametersT< double > | skeletonStateToJointParameters (const SkeletonStateT< double > &state, const Skeleton &skeleton) |
| |
| template JointParametersT< float > | skeletonStateToJointParameters (const TransformListT< float > &state, const Skeleton &skeleton) |
| |
| template JointParametersT< double > | skeletonStateToJointParameters (const TransformListT< double > &state, const Skeleton &skeleton) |
| |
| template JointParametersT< float > | skeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< float > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams) |
| |
| template JointParametersT< double > | skeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< double > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams) |
| |
| template JointParametersT< float > | skeletonStateToJointParametersRespectingActiveParameters (const TransformListT< float > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams) |
| |
| template JointParametersT< double > | skeletonStateToJointParametersRespectingActiveParameters (const TransformListT< double > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams) |
| |
| ModelParameters | extrapolateModelParameters (const ModelParameters &previous, const ModelParameters ¤t, float factor=kDefaultExtrapolateFactor, float maxDelta=kDefaultExtrapolateMaxDelta) |
| | Extrapolates model parameters by first clamping the difference between current and previous parameters to the range [-maxDelta, maxDelta], and then scaling this clamped difference by factor.
|
| |
| ModelParameters | extrapolateModelParameters (const ModelParameters &previous, const ModelParameters ¤t, const ParameterSet &activeParams, float factor=kDefaultExtrapolateFactor, float maxDelta=kDefaultExtrapolateMaxDelta) |
| | Extrapolates model parameters considering active parameters.
|
| |
| template<typename T > |
| void | gradient_jointParams_to_modelParams (const T &grad_jointParams, const Eigen::Index iJointParam, const ParameterTransform ¶meterTransform, Eigen::Ref< Eigen::VectorX< T > > gradient) |
| |
| template<typename T > |
| void | jacobian_jointParams_to_modelParams (const Eigen::Ref< const Eigen::VectorX< T > > &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform ¶meterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian) |
| |
| template<typename T > |
| void | jacobian_jointParams_to_modelParams (const T &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform ¶meterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian) |
| |
| template<typename T > |
| std::vector< PlaneDataT< T > > | createFloorConstraints (const std::string &prefix, const LocatorList &locators, const Vector3< T > &floorNormal, const T &floorOffset, float weight) |
| | Create non-penetration half-plane constraints from locators with the input prefix.
|
| |
| template std::vector< PlaneDataT< float > > | createFloorConstraints< float > (const std::string &prefix, const LocatorList &locators, const Vector3f &floorNormal, const float &floorOffset, const float weight) |
| |
| template std::vector< PlaneDataT< double > > | createFloorConstraints< double > (const std::string &prefix, const LocatorList &locators, const Vector3d &floorNormal, const double &floorOffset, const float weight) |
| |
| template<typename T > |
| Eigen::Vector3< T > | computeTargetBaryPosition (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c) |
| |
| template<typename T > |
| Eigen::Vector3< T > | computeTargetTriangleNormal (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c) |
| |
| template<typename T > |
| Eigen::Vector3< T > | computeTargetPosition (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c) |
| |
| template<typename T > |
| void | gradient_jointParams_to_modelParams (const T grad_jointParams, const Eigen::Index iJointParam, const ParameterTransform ¶meterTransform, Eigen::Ref< Eigen::VectorX< T > > gradient) |
| |
| template<typename T > |
| void | jacobian_jointParams_to_modelParams (const Eigen::Ref< const Eigen::VectorX< T > > jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform ¶meterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian) |
| |
| template<typename T > |
| void | jacobian_jointParams_to_modelParams (const T jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform ¶meterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian) |
| |
| template<typename T > |
| Eigen::Vector3< T > | calculateDWorldPos (const momentum::Character &character, const SkeletonStateT< T > &state, const int vertexIndex, const Eigen::Vector3< T > &d_restPos) |
| |
| template<typename T > |
| std::array< Eigen::Matrix3< T >, 3 > | compute_d_targetNormal_d_vertexPos (const PointTriangleVertexConstraintT< T > &cons, const MeshT< T > &mesh) |
| |
| template<typename T > |
| std::array< Eigen::Matrix3< T >, 3 > | compute_d_targetPos_d_vertexPos (const PointTriangleVertexConstraintT< T > &cons, const MeshT< T > &mesh) |
| |
| template<typename T > |
| Eigen::VectorX< T > | mapParameters (const ModelParametersT< T > &in, const std::vector< size_t > &mp) |
| |
| __vectorcall DRJIT_INLINE void | jacobian_jointParams_to_modelParams (const FloatP &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform ¶meterTransform_, Eigen::Ref< Eigen::MatrixX< float > > jacobian) |
| |
| template<typename T > |
| std::pair< size_t, std::vector< size_t > > | getDimensions (const std::vector< std::shared_ptr< SkeletonErrorFunctionT< T > > > &error_func) |
| |
| template<typename T > |
| Eigen::Vector3< T > | computeTargetBaryPosition (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c) |
| |
| template<typename T > |
| Eigen::Vector3< T > | computeTargetTriangleNormal (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c) |
| |
| template<typename T > |
| Eigen::Vector3< T > | computeTargetPosition (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c) |
| |
| template<typename T > |
| std::array< Eigen::Matrix3< T >, 3 > | compute_d_targetNormal_d_vertexPos (const SkinnedLocatorTriangleConstraintT< T > &cons, const MeshT< T > &mesh) |
| |
| template<typename T > |
| std::array< Eigen::Matrix3< T >, 3 > | compute_d_targetPos_d_vertexPos (const SkinnedLocatorTriangleConstraintT< T > &cons, const MeshT< T > &mesh) |
| |
| template<typename T > |
| std::vector< ModelParametersT< T > > | transformPose (const Character &character, const std::vector< ModelParametersT< T > > &modelParameters, const TransformT< T > &transforms) |
| |
| template<typename T > |
| std::vector< ModelParametersT< T > > | transformPose (const Character &character, const std::vector< ModelParametersT< T > > &modelParameters, const std::vector< TransformT< T > > &transforms, bool ensureContinuousOutput=true) |
| | Function which computes a new set of model parameters such that the character pose is a rigidly transformed version of the original pose.
|
| |
| template std::vector< ModelParametersT< float > > | transformPose (const Character &characterFull, const std::vector< ModelParametersT< float > > &modelParametersFull, const std::vector< TransformT< float > > &transforms, bool ensureContinuousOutput) |
| |
| template std::vector< ModelParametersT< double > > | transformPose (const Character &characterFull, const std::vector< ModelParametersT< double > > &modelParametersFull, const std::vector< TransformT< double > > &transforms, bool ensureContinuousOutput) |
| |
| template std::vector< ModelParametersT< float > > | transformPose (const Character &character, const std::vector< ModelParametersT< float > > &modelParameters, const TransformT< float > &transform) |
| |
| template std::vector< ModelParametersT< double > > | transformPose (const Character &character, const std::vector< ModelParametersT< double > > &modelParameters, const TransformT< double > &transform) |
| |
| std::string_view | toString (VertexConstraintType type) |
| |
| template<typename T , typename T2 > |
| Eigen::Vector3< T > | getRotationDerivative (const JointStateT< T2 > &js, const size_t index, const Eigen::Vector3< T > &ref) |
| |
| template<typename T , typename T2 > |
| Eigen::Vector3< T > | getScaleDerivative (const JointStateT< T2 > &js, const Eigen::Vector3< T > &ref) |
| |
| template<typename T , int N> |
| Eigen::Matrix< ceres::Jet< T, N >, N, 1 > | buildJetVec (const Eigen::Matrix< T, N, 1 > &v) |
| |
| template<typename T , int Rows, int Cols> |
| Eigen::Matrix< ceres::Jet< T, Cols *Rows >, Rows, Cols > | buildJetMat (const Eigen::Matrix< T, Rows, Cols > &m) |
| |
| template<typename T , typename T2 > |
| T | times_parameterTransform_times_v (const T &value, const size_t jointParamIdx, const ParameterTransform ¶meterTransform, Eigen::Ref< const Eigen::VectorX< T2 > > v) |
| |
| template<typename T > |
| std::vector< Eigen::Index > | computeSubsetParameterIndices (const ParameterTransformT< T > ¶meterTransform, const ParameterSet &activeParams) |
| |
| template<typename T > |
| Eigen::VectorX< T > | extractSubsetVec (Eigen::Ref< const Eigen::VectorX< T > > fullVec, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex) |
| |
| template<typename T > |
| Eigen::MatrixX< T > | extractSubsetMat (Eigen::Ref< const Eigen::MatrixX< T > > fullMat, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex) |
| |
| template<typename T > |
| Eigen::VectorX< T > | subsetVecToFullVec (Eigen::Ref< const Eigen::VectorX< T > > subsetVec, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex, Eigen::Index fullVecSize) |
| |
| float | sqr (float val) |
| |
| template<typename T > |
| Eigen::VectorX< T > | hessianInverseTimes (Eigen::Ref< const Eigen::MatrixX< T > > jacobian, Eigen::Ref< const Eigen::VectorX< T > > v) |
| |
| template<typename T > |
| std::vector< ErrorFunctionDerivativesT< T > > | d_modelParams_d_inputs (const Skeleton &skeleton, const ParameterTransformT< T > ¶meterTransform, const ParameterSet &activeParams, const ModelParametersT< T > &modelParameters, SkeletonSolverFunctionT< T > &solverFunction, Eigen::Ref< const Eigen::VectorX< T > > dLoss_dModelParams, T *gradientRmse) |
| |
| template std::vector< ErrorFunctionDerivativesT< float > > | d_modelParams_d_inputs< float > (const Skeleton &skeleton, const ParameterTransformT< float > ¶meterTransform, const ParameterSet &activeParams, const ModelParametersT< float > &modelParameters, SkeletonSolverFunctionT< float > &solverFunction, Eigen::Ref< const Eigen::VectorX< float > > dLoss_dModelParams, float *gradientRmse) |
| |
| template std::vector< ErrorFunctionDerivativesT< double > > | d_modelParams_d_inputs< double > (const Skeleton &skeleton, const ParameterTransformT< double > ¶meterTransform, const ParameterSet &activeParams, const ModelParametersT< double > &modelParameters, SkeletonSolverFunctionT< double > &solverFunction, Eigen::Ref< const Eigen::VectorX< double > > dLoss_dModelParams, double *gradientRmse) |
| |
| | MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS (DistanceErrorFunction) |
| |
| | MOMENTUM_FWD_DECLARE_TEMPLATE_STRUCT (DistanceConstraintData) |
| |
| | MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS (FullyDifferentiableProjectionErrorFunction) |
| |
| Character | loadFullCharacter (const std::string &characterPath, const std::string ¶metersPath=std::string(), const std::string &locatorsPath=std::string()) |
| | High level function to load a character of any type, with a local path.
|
| |
| Character | loadFullCharacterFromBuffer (CharacterFormat format, std::span< const std::byte > characterBuffer, std::span< const std::byte > paramBuffer=std::span< const std::byte >(), std::span< const std::byte > locBuffer=std::span< const std::byte >()) |
| | Buffer version of loadFullCharacter function, supports .glb and .fbx file formats.
|
| |
| void | saveCharacter (const filesystem::path &filename, const Character &character, float fps=120.f, const MatrixXf &motion=MatrixXf(), std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions()) |
| | High level function to save a character with motion and markers to any supported format.
|
| |
| void | saveCharacter (const filesystem::path &filename, const Character &character, float fps, std::span< const SkeletonState > skeletonStates, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions()) |
| | High level function to save a character with motion in skeleton states and markers to any supported format.
|
| |
| template<typename T > |
| std::span< T > | cast_span (std::span< std::byte > bs) |
| | Casts a span of bytes to a span of a different type.
|
| |
| template<typename T > |
| std::span< const T > | cast_span (std::span< const std::byte > bs) |
| | Casts a span of const bytes to a span of a different type.
|
| |
| std::istream & | GetLineCrossPlatform (std::istream &is, std::string &line) |
| | Reads a line from the input stream, handling line endings for different platforms.
|
| |
| Character | loadFbxCharacter (const filesystem::path &inputPath, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| Character | loadFbxCharacter (std::span< const std::byte > inputSpan, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| std::tuple< Character, std::vector< MatrixXf >, float > | loadFbxCharacterWithMotion (const filesystem::path &inputPath, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| std::tuple< Character, std::vector< MatrixXf >, float > | loadFbxCharacterWithMotion (std::span< const std::byte > inputSpan, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| MarkerSequence | loadFbxMarkerSequence (const filesystem::path &filename, bool stripNamespaces=true) |
| | Loads a MarkerSequence from an FBX file.
|
| |
| void | saveFbx (const filesystem::path &filename, const Character &character, const MatrixXf &poses=MatrixXf(), const VectorXf &identity=VectorXf(), double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions()) |
| | Save a character with animation to an FBX file.
|
| |
| void | saveFbxWithJointParams (const filesystem::path &filename, const Character &character, const MatrixXf &jointParams=MatrixXf(), double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions()) |
| | Save a character with animation using joint parameters directly.
|
| |
| void | saveFbxWithSkeletonStates (const filesystem::path &filename, const Character &character, std::span< const SkeletonState > skeletonStates, double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions()) |
| | Save a character with animation using skeleton states directly.
|
| |
| void | saveFbxModel (const filesystem::path &filename, const Character &character, const FileSaveOptions &options=FileSaveOptions()) |
| | Save a character model (skeleton and mesh) without animation.
|
| |
| Character | loadOpenFbxCharacter (const std::span< const std::byte > inputData, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| Character | loadOpenFbxCharacter (const filesystem::path &path, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| std::tuple< Character, std::vector< MatrixXf >, float > | loadOpenFbxCharacterWithMotion (std::span< const std::byte > inputData, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| std::tuple< Character, std::vector< MatrixXf >, float > | loadOpenFbxCharacterWithMotion (const filesystem::path &inputPath, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces) |
| |
| MarkerSequence | loadOpenFbxMarkerSequence (const filesystem::path &filename, bool stripNamespaces) |
| |
| std::vector< Eigen::Vector3i > | triangulate (std::span< const uint32_t > indices, std::span< const uint32_t > offsets) |
| |
| Character | loadGltfCharacter (const fx::gltf::Document &model) |
| |
| Character | loadGltfCharacter (const filesystem::path &gltfFilename) |
| |
| Character | loadGltfCharacter (std::span< const std::byte > byteSpan) |
| |
| std::tuple< MotionParameters, IdentityParameters, float > | loadMotion (const filesystem::path &gltfFilename) |
| |
| std::tuple< Character, MatrixXf, VectorXf, float > | loadCharacterWithMotion (const filesystem::path &gltfFilename) |
| | Load a glTF character from a local file path.
|
| |
| std::tuple< Character, MatrixXf, VectorXf, float > | loadCharacterWithMotion (std::span< const std::byte > byteSpan) |
| | Load a glTF character from a buffer.
|
| |
| std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > | loadCharacterWithSkeletonStates (std::span< const std::byte > byteSpan) |
| | Load a GLTF Character with motion in the form of skeleton states (transform matrices)
|
| |
| std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > | loadCharacterWithSkeletonStates (const filesystem::path &gltfFilename) |
| |
| std::tuple< MatrixXf, VectorXf, float > | loadMotionOnCharacter (const filesystem::path &gltfFilename, const Character &character) |
| | Maps the loaded motion onto the input character by matching joint names and parameter names.
|
| |
| std::tuple< MatrixXf, VectorXf, float > | loadMotionOnCharacter (std::span< const std::byte > byteSpan, const Character &character) |
| | Buffer version of loadMotionOnCharacter()
|
| |
| fx::gltf::Document | makeCharacterDocument (const Character &character, const float fps, const MotionParameters &motion, const IdentityParameters &offsets, std::span< const std::vector< Marker > > markerSequence, bool embedResource, const FileSaveOptions &options) |
| |
| MarkerSequence | loadMarkerSequence (const filesystem::path &filename) |
| | Loads a MarkerSequence from a file.
|
| |
| void | saveGltfCharacter (const filesystem::path &filename, const Character &character, float fps=120.0f, const MotionParameters &motion={}, const IdentityParameters &offsets={}, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions()) |
| | Saves character motion to a glb file.
|
| |
| void | saveGltfCharacter (const filesystem::path &filename, const Character &character, float fps, std::span< const SkeletonState > skeletonStates, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions()) |
| | Saves character skeleton states to a glb file.
|
| |
| std::vector< std::byte > | saveCharacterToBytes (const Character &character, float fps, const MotionParameters &motion, const IdentityParameters &offsets, std::span< const std::vector< Marker > > markerSequence, const FileSaveOptions &options) |
| |
| template<typename T > |
| std::vector< T > | copyAccessorBuffer (const fx::gltf::Document &model, int32_t id) |
| |
| template<typename T > |
| std::vector< T > | copyAlignedAccessorBuffer (const fx::gltf::Document &model, int32_t id) |
| |
| template<typename T > |
| void | setAccessorType (fx::gltf::Accessor &) |
| |
| template<typename T > |
| int32_t | createAccessorBuffer (fx::gltf::Document &model, std::span< T > data, const bool align=false, const bool normalized=false) |
| |
| template<> |
| void | setAccessorType< const int32_t > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const float > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const Vector2f > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const Vector3f > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const Vector4f > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const Vector3b > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const Vector3i > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const Vector4s > (fx::gltf::Accessor &accessor) |
| |
| template<> |
| void | setAccessorType< const Matrix4f > (fx::gltf::Accessor &accessor) |
| |
| template<typename T > |
| int32_t | createSampler (fx::gltf::Document &model, fx::gltf::Animation &anim, std::span< T > data, const std::span< float > ×tamps) |
| |
| template<typename T > |
| int32_t | createSampler (fx::gltf::Document &model, fx::gltf::Animation &anim, std::span< T > data, const int32_t timestampAccessor) |
| |
| Vector3f | toMomentumVec3f (const std::array< float, 3 > &vec) noexcept |
| |
| Vector3f | fromMomentumVec3f (const Vector3f &vec) noexcept |
| |
| Quaternionf | toMomentumQuaternionf (const std::array< float, 4 > &gltfQuat) noexcept |
| |
| std::array< float, 4 > | fromMomentumQuaternionf (const Quaternionf &quat) noexcept |
| |
| void | toMomentumVec3f (std::vector< Vector3f > &vec) |
| |
| void | fromMomentumVec3f (std::vector< Vector3f > &vec) |
| |
| void | fromMomentumVec3f (VectorXf &vec) |
| |
| void | parameterSetsToJson (const Character &character, nlohmann::json &j) |
| |
| ParameterSets | parameterSetsFromJson (const Character &character, const nlohmann::json &j) |
| |
| void | poseConstraintsToJson (const Character &character, nlohmann::json &j) |
| |
| PoseConstraints | poseConstraintsFromJson (const Character &character, const nlohmann::json &j) |
| |
| void | parameterTransformToJson (const Character &character, nlohmann::json &j) |
| |
| ParameterTransform | parameterTransformFromJson (const Character &character, const nlohmann::json &j) |
| |
| void | parameterLimitsToJson (const Character &character, nlohmann::json &j) |
| |
| ParameterLimits | parameterLimitsFromJson (const Character &character, const nlohmann::json &j) |
| |
| template<typename Derived > |
| void | toJson (const Eigen::MatrixBase< Derived > &mat, nlohmann::json &j) |
| |
| template<typename T > |
| T | fromJson (const nlohmann::json &j) |
| |
| void | mppcaToJson (const Character &character, nlohmann::json &j) |
| |
| Character | loadCharacterFromLegacyJson (const std::string &jsonPath) |
| | Loads a Character from a legacy JSON format that was previously used by older Python libraries (and some other tools).
|
| |
| Character | loadCharacterFromLegacyJsonBuffer (std::span< const std::byte > jsonBuffer) |
| | Loads a Character from a legacy JSON buffer.
|
| |
| Character | loadCharacterFromLegacyJsonString (const std::string &jsonString) |
| | Loads a Character from a legacy JSON string.
|
| |
| void | saveCharacterToLegacyJson (const Character &character, const std::string &jsonPath) |
| | Saves a Character to legacy JSON format.
|
| |
| std::string | characterToLegacyJsonString (const Character &character) |
| | Converts a Character to legacy JSON string.
|
| |
| nlohmann::json | characterToLegacyJson (const Character &character) |
| | Converts a Character to legacy JSON object.
|
| |
| std::vector< MarkerSequence > | loadC3d (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={}) |
| | Loads all the subjects from a C3D file into a vector of MarkerSequences.
|
| |
| template<typename T > |
| Vector3< T > | toMomentumVector3 (const Vector3< T > &vec, UpVector up=UpVector::Z, Unit unit=Unit::MM) |
| | This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system.
|
| |
| template<typename T > |
| Vector3< T > | toMomentumVector3 (const Vector3< T > &vec, UpVector up, const std::string &unitStr) |
| | This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system, using a string to specify the unit.
|
| |
| template Vector3< float > | toMomentumVector3 (const Vector3< float > &vec, UpVector up, Unit unit) |
| |
| template Vector3< double > | toMomentumVector3 (const Vector3< double > &vec, UpVector up, Unit unit) |
| |
| template Vector3< float > | toMomentumVector3 (const Vector3< float > &vec, UpVector up, const std::string &unitStr) |
| |
| template Vector3< double > | toMomentumVector3 (const Vector3< double > &vec, UpVector up, const std::string &unitStr) |
| |
| std::vector< MarkerSequence > | loadMarkers (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={}) |
| | Loads all actor sequences from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.
|
| |
| std::optional< MarkerSequence > | loadMarkersForMainSubject (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={}) |
| | Loads the main subject's marker data from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.
|
| |
| int | findMainSubjectIndex (std::span< const MarkerSequence > markerSequences) |
| | Finds the "main subject" from a vector of MarkerSequences.
|
| |
| MarkerSequence | loadTrc (const std::string &filename, UpVector up=UpVector::Y) |
| | Loads marker data from a TRC file into a MarkerSequence.
|
| |
| void | saveMmo (const std::string &filename, std::span< const VectorXf > poses, const VectorXf &scale, const Character &character) |
| | Save motion data using character parameter mapping.
|
| |
| void | saveMmo (const std::string &filename, const MatrixXf &poses, const VectorXf &scale, const Character &character, const MatrixXf &additionalParameters=MatrixXf(), std::span< const std::string > additionalParameterNames=std::vector< std::string >()) |
| | Save motion data with optional additional parameters.
|
| |
| void | saveMmo (const std::string &filename, const MatrixXf &poses, const VectorXf &scale, std::span< const std::string > parameterNames, std::span< const std::string > jointNames) |
| | Save motion data with explicit parameter and joint names.
|
| |
| std::tuple< MatrixXf, VectorXf > | mapMotionToCharacter (const MatrixXf &poses, const VectorXf &offsets, std::span< const std::string > parameterNames, std::span< const std::string > jointNames, const Character &character) |
| | Map motion data from one parameter space to character parameter space.
|
| |
| std::tuple< MatrixXf, VectorXf > | loadMmo (const std::string &filename, const Character &character) |
| | Load motion data and map to character parameter space.
|
| |
| std::tuple< MatrixXf, std::vector< std::string > > | getAuxiliaryDataFromMotion (const MatrixXf &poses, std::span< const std::string > parameterNames) |
| | Extract auxiliary data from motion parameters.
|
| |
| std::tuple< MatrixXf, VectorXf, std::vector< std::string >, std::vector< std::string > > | loadMmo (const std::string &filename) |
| | Load motion data from file.
|
| |
| BlendShapeBase | loadBlendShapeBase (const filesystem::path &filename, int expectedShapes=-1, int expectedVertices=-1) |
| | Loads blend shape vectors from a file without base shape.
|
| |
| BlendShapeBase | loadBlendShapeBase (std::istream &data, int expectedShapes=-1, int expectedVertices=-1) |
| | Loads blend shape vectors from a stream without base shape.
|
| |
| BlendShape | loadBlendShape (const filesystem::path &filename, int expectedShapes=-1, int expectedVertices=-1) |
| | Loads a blend shape from a file, including base shape and shape vectors.
|
| |
| BlendShape | loadBlendShape (std::istream &data, int expectedShapes=-1, int expectedVertices=-1) |
| | Loads a blend shape from a stream, including base shape and shape vectors.
|
| |
| void | saveBlendShape (const filesystem::path &filename, const BlendShape &blendShape) |
| | Saves a blend shape to a file.
|
| |
| void | saveBlendShape (std::ostream &os, const BlendShape &blendShape) |
| | Saves a blend shape to a stream.
|
| |
| PoseShape | loadPoseShape (const std::string &filename, const Character &character) |
| | Loads pose shape data from a binary file.
|
| |
| LocatorList | loadLocators (const filesystem::path &filename, const Skeleton &skeleton, const ParameterTransform ¶meterTransform) |
| |
| LocatorList | loadLocatorsFromBuffer (std::span< const std::byte > rawData, const Skeleton &skeleton, const ParameterTransform ¶meterTransform) |
| |
| void | saveLocators (const filesystem::path &filename, const LocatorList &locators, const Skeleton &skeleton, const LocatorSpace space) |
| |
| std::shared_ptr< const Mppca > | loadMppca (const std::span< const unsigned char > posePriorDataRaw) |
| |
| std::shared_ptr< const Mppca > | loadMppca (const std::string &name) |
| |
| std::shared_ptr< const Mppca > | loadMppca (std::istream &inputStream) |
| |
| void | saveMppca (const Mppca &mppca, const std::string &name) |
| |
| ParameterLimits | parseParameterLimits (const io_detail::SectionContent &content, const Skeleton &skeleton, const ParameterTransform ¶meterTransform) |
| |
| ParameterLimits | parseParameterLimits (const std::string &data, const Skeleton &skeleton, const ParameterTransform ¶meterTransform, size_t lineOffset) |
| |
| std::string | writeParameterLimits (const ParameterLimits ¶meterLimits, const Skeleton &skeleton, const ParameterTransform ¶meterTransform) |
| |
| std::unordered_map< std::string, std::string > | loadMomentumModel (const filesystem::path &filename) |
| |
| std::unordered_map< std::string, std::string > | loadMomentumModelFromBuffer (std::span< const std::byte > buffer) |
| |
| ParameterTransform | parseParameterTransform (const SectionContent &content, const Skeleton &skeleton) |
| |
| ParameterTransform | parseParameterTransform (const std::string &data, const Skeleton &skeleton, size_t lineOffset) |
| |
| ParameterSets | parseParameterSets (const SectionContent &content, const ParameterTransform &pt) |
| |
| ParameterSets | parseParameterSets (const std::string &data, const ParameterTransform &pt, size_t lineOffset) |
| |
| PoseConstraints | parsePoseConstraints (const SectionContent &content, const ParameterTransform &pt) |
| |
| PoseConstraints | parsePoseConstraints (const std::string &data, const ParameterTransform &pt, size_t lineOffset) |
| |
| std::tuple< ParameterTransform, ParameterLimits > | loadModelDefinition (const filesystem::path &filename, const Skeleton &skeleton) |
| |
| std::tuple< ParameterTransform, ParameterLimits > | loadModelDefinition (std::span< const std::byte > rawData, const Skeleton &skeleton) |
| |
| std::string | writeParameterTransform (const ParameterTransform ¶meterTransform, const Skeleton &skeleton) |
| |
| std::string | writeParameterSets (const ParameterSets ¶meterSets) |
| |
| std::string | writePoseConstraints (const PoseConstraints &poseConstraints) |
| |
| std::string | writeModelDefinition (const Skeleton &skeleton, const ParameterTransform ¶meterTransform, const ParameterLimits ¶meterLimits) |
| | Write complete model definition file.
|
| |
| ParameterTransform | parseParameterTransform (const io_detail::SectionContent &content, const Skeleton &skeleton) |
| |
| ParameterSets | parseParameterSets (const io_detail::SectionContent &content, const ParameterTransform &pt) |
| |
| PoseConstraints | parsePoseConstraints (const io_detail::SectionContent &content, const ParameterTransform &pt) |
| |
| void | loadParameters (std::unordered_map< std::string, std::string > ¶m, Character &character) |
| |
| template<typename T > |
| CharacterT< T > | loadUrdfCharacter (const filesystem::path &filepath) |
| | Loads a character from a URDF file.
|
| |
| template CharacterT< float > | loadUrdfCharacter (const filesystem::path &filepath) |
| |
| template<typename T > |
| CharacterT< T > | loadUrdfCharacter (std::span< const std::byte > bytes) |
| | Loads a character from a URDF file using the provided byte data.
|
| |
| template CharacterT< float > | loadUrdfCharacter (std::span< const std::byte > bytes) |
| |
| Character | loadUsdCharacter (const filesystem::path &inputPath) |
| | Load a USD character from a local file path.
|
| |
| Character | loadUsdCharacter (std::span< const std::byte > inputSpan) |
| | Load a USD character from a buffer.
|
| |
| void | saveUsd (const filesystem::path &filename, const Character &character) |
| | Save a character to a USD file.
|
| |
| void | logMesh (const rerun::RecordingStream &rec, const std::string &streamName, const Mesh &mesh, std::optional< rerun::Color > color) |
| |
| void | logJoints (const rerun::RecordingStream &rec, const std::string &streamName, const Skeleton &skeleton, const JointStateList &jointStates) |
| |
| void | logMarkers (const rerun::RecordingStream &rec, const std::string &streamName, std::span< const Marker > markers) |
| |
| void | logLocators (const rerun::RecordingStream &rec, const std::string &streamName, const LocatorList &locators, const LocatorState &locatorState) |
| |
| void | logMarkerLocatorCorrespondence (const rerun::RecordingStream &rec, const std::string &streamName, const std::map< std::string, size_t > &locatorLookup, const LocatorState &locatorState, std::span< const Marker > markers, const float kPositionErrorThreshold) |
| |
| void | logModelParams (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names, const Eigen::VectorXf ¶ms) |
| |
| void | logJointParams (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names, const Eigen::VectorXf ¶ms) |
| |
| void | logModelParamNames (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names) |
| |
| void | logJointParamNames (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names) |
| |
| void | logBvh (const rerun::RecordingStream &rec, const std::string &streamName, const CollisionGeometry &collisionGeometry, const SkeletonState &skeletonState) |
| |
| void | logCollisionGeometry (const rerun::RecordingStream &rec, const std::string &streamName, const CollisionGeometry &collisionGeometry, const SkeletonState &skeletonState) |
| |
| void | logCharacter (const rerun::RecordingStream &rec, const std::string &charStreamName, const Character &character, const CharacterState &characterState, const rerun::Color &color) |
| |
| bool | redirectLogsToRerun (const rerun::RecordingStream &rec) |
| | Redirects logs from the XR_LOG framework to the Rerun logger.
|
| |
| void | addIOOptions (CLI::App &app, std::shared_ptr< IOOptions > ioOptions) |
| |
| void | addModelOptions (CLI::App &app, std::shared_ptr< ModelOptions > modelOptions) |
| |
| void | addCalibrationOptions (CLI::App &app, std::shared_ptr< CalibrationConfig > config) |
| |
| void | addTrackingOptions (CLI::App &app, std::shared_ptr< TrackingConfig > config) |
| |
| void | addRefineOptions (CLI::App &app, std::shared_ptr< RefineConfig > config) |
| |
| std::tuple< momentum::Character, momentum::ModelParameters > | loadCalibratedModel (const std::string &modelFile) |
| |
| std::tuple< momentum::Character, momentum::ModelParameters > | loadCharacterWithIdentity (const ModelOptions &modelFiles) |
| |
| void | saveMotion (const std::string &outFile, const momentum::Character &character, const momentum::ModelParameters &identity, Eigen::MatrixXf &finalMotion, std::span< const std::vector< momentum::Marker > > markerData, double fps, bool saveMarkerMesh=true) |
| | Save the given character and motion to a GLB or FBX file.
|
| |
| std::vector< size_t > | sampleFrames (momentum::Character &character, const MatrixXf &initialMotion, std::span< const std::vector< momentum::Marker > > markerData, const ParameterSet ¶meters, const size_t frameStride, const size_t numSamples) |
| | Sample representative frames from motion data to maximize parameter variance.
|
| |
| Eigen::MatrixXf | trackSequence (const std::span< const std::vector< Marker > > markerData, const Character &character, const ParameterSet &globalParams, const MatrixXf &initialMotion, const TrackingConfig &config, float regularizer, const size_t frameStride, bool enforceFloorInFirstFrame, const std::string &firstFramePoseConstraintSet) |
| | Track motion across multiple frames simultaneously with temporal constraints.
|
| |
| Eigen::MatrixXf | trackSequence (const std::span< const std::vector< Marker > > markerData, const Character &character, const ParameterSet &globalParams, const MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frames, float regularizer, bool enforceFloorInFirstFrame, const std::string &firstFramePoseConstraintSet) |
| | Track motion across multiple frames simultaneously for specific frame indices.
|
| |
| bool | isGlobalTransformZero (const Eigen::VectorXf &dof, const ParameterSet &rigidParams) |
| | Check if the global transform is zero by checking if any rigid parameters are non-zero.
|
| |
| Eigen::MatrixXf | trackPosesPerframe (const std::span< const std::vector< Marker > > markerData, const Character &character, const ModelParameters &globalParams, const TrackingConfig &config, const size_t frameStride) |
| | Track poses independently per frame with fixed character identity.
|
| |
| Eigen::MatrixXf | trackPosesForFrames (const std::span< const std::vector< Marker > > markerData, const Character &character, const MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frameIndices, bool isContinuous) |
| | Track poses independently for specific frame indices with fixed character identity.
|
| |
| Character | addSkinnedLocatorParametersToTransform (Character character) |
| |
| void | calibrateModel (const std::span< const std::vector< Marker > > markerData, const CalibrationConfig &config, Character &character, ModelParameters &identity) |
| | Calibrate character identity parameters (scaling, locators, blend shapes) from marker data.
|
| |
| void | calibrateLocators (const std::span< const std::vector< Marker > > markerData, const CalibrationConfig &config, const ModelParameters &identity, Character &character) |
| | Calibrate only locator positions with fixed character identity parameters.
|
| |
| MatrixXf | refineMotion (std::span< const std::vector< momentum::Marker > > markerData, const MatrixXf &motion, const RefineConfig &config, momentum::Character &character) |
| | Refine existing motion by smoothing and optionally recalibrating identity/locators.
|
| |
| std::pair< float, float > | getLocatorError (std::span< const std::vector< momentum::Marker > > markerData, const MatrixXf &motion, momentum::Character &character) |
| | Compute average and maximum marker tracking errors across all frames.
|
| |
| Eigen::MatrixXf | trackSequence (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ParameterSet &globalParams, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, float regularizer=0.0, size_t frameStride=1, bool enforceFloorInFirstFrame=false, const std::string &firstFramePoseConstraintSet="") |
| | Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.
|
| |
| Eigen::MatrixXf | trackSequence (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ParameterSet &globalParams, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frames, float regularizer=0.0, bool enforceFloorInFirstFrame=false, const std::string &firstFramePoseConstraintSet="") |
| | Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.
|
| |
| Eigen::MatrixXf | trackPosesPerframe (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ModelParameters &globalParams, const TrackingConfig &config, size_t frameStride=1) |
| | Track poses per-frame given a calibrated character.
|
| |
| Eigen::MatrixXf | trackPosesForFrames (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frameIndices, bool isContinuous=false) |
| | Track poses for given frames.
|
| |
| void | calibrateModel (std::span< const std::vector< momentum::Marker > > markerData, const CalibrationConfig &config, momentum::Character &character, momentum::ModelParameters &identity) |
| | Calibrate body proportions and locator offsets of a character from input marker data.
|
| |
| void | calibrateLocators (std::span< const std::vector< momentum::Marker > > markerData, const CalibrationConfig &config, const momentum::ModelParameters &identity, momentum::Character &character) |
| | Calibrate locator offsets of a character from input identity and marker data.
|
| |
| Eigen::MatrixXf | refineMotion (std::span< const std::vector< momentum::Marker > > markerData, const Eigen::MatrixXf &motion, const RefineConfig &config, momentum::Character &character) |
| |
| std::pair< float, float > | getLocatorError (std::span< const std::vector< momentum::Marker > > markerData, const Eigen::MatrixXf &motion, momentum::Character &character) |
| | Get the error of the locator motion vs the markers.
|
| |
| Eigen::MatrixXf | processMarkers (momentum::Character &character, momentum::ModelParameters &identity, const std::vector< std::vector< momentum::Marker > > &markerData, const TrackingConfig &trackingConfig, const CalibrationConfig &calibrationConfig, bool calibrate=true, size_t firstFrame=0, size_t maxFrames=0) |
| | Processes marker data for a character model.
|
| |
| void | processMarkerFile (const std::string &inputMarkerFile, const std::string &outputFile, const TrackingConfig &trackingConfig, const CalibrationConfig &calibrationConfig, const ModelOptions &modelOptions, bool calibrate, size_t firstFrame=0, size_t maxFrames=0) |
| | Runs marker tracking on an input marker file (e.g.
|
| |
| std::vector< std::vector< PositionData > > | createConstraintData (const std::span< const std::vector< Marker > > markerData, const LocatorList &locators) |
| |
| std::vector< std::vector< SkinnedLocatorConstraint > > | createSkinnedConstraintData (const std::span< const std::vector< Marker > > markerData, const SkinnedLocatorList &locators) |
| |
| std::pair< Eigen::Vector< uint32_t, kMaxSkinJoints >, Eigen::Vector< float, kMaxSkinJoints > > | averageTriangleSkinWeights (const Character &character, int triangleIndex, const Eigen::Vector3f &barycentric) |
| |
| ClosestPointOnMeshResult | closestPointOnMeshMatchingParent (const momentum::Mesh &mesh, const momentum::SkinWeights &skin, const Eigen::Vector3f &p_world, uint32_t parentIdx, float cutoffWeight=0.1) |
| |
| momentum::Character | locatorsToSkinnedLocators (const momentum::Character &sourceCharacter, float maxDistance=3.0f) |
| | Convert locators to skinned locators by finding the closest point on the mesh surface that matches the correct bone index and using the skinned weights from that point.
|
| |
| std::vector< momentum::SkinnedLocatorTriangleConstraintT< float > > | createSkinnedLocatorMeshConstraints (const momentum::Character &character, float targetDepth) |
| |
| Character | createLocatorCharacter (const Character &sourceCharacter, const std::string &prefix) |
| |
| LocatorList | extractLocatorsFromCharacter (const Character &locatorCharacter, const CharacterParameters &calibParams) |
| |
| SkinnedLocatorList | extractSkinnedLocatorsFromCharacter (const Character &locatorCharacter, const CharacterParameters &calibParams) |
| |
| ModelParameters | extractParameters (const ModelParameters ¶ms, const ParameterSet ¶meterSet) |
| |
| std::tuple< Eigen::VectorXf, LocatorList, SkinnedLocatorList > | extractIdAndLocatorsFromParams (const ModelParameters ¶m, const Character &sourceCharacter, const Character &targetCharacter) |
| |
| Mesh | extractBlendShapeFromParams (const momentum::ModelParameters ¶m, const momentum::Character &sourceCharacter) |
| |
| void | fillIdentity (const ParameterSet &idSet, const ModelParameters &identity, Eigen::MatrixXf &motionNoId) |
| |
| void | removeIdentity (const ParameterSet &idSet, const ModelParameters &identity, Eigen::MatrixXf &motionWithId) |
| |
| ModelParameters | jointIdentityToModelIdentity (const Character &c, const ParameterSet &idSet, const JointParameters &jointIdentity) |
| |
| std::vector< std::vector< Marker > > | extractMarkersFromMotion (const Character &character, const Eigen::MatrixXf &motion) |
| |
| std::vector< std::vector< momentum::PositionData > > | createConstraintData (std::span< const std::vector< momentum::Marker > > markerData, const momentum::LocatorList &locators) |
| |
| std::vector< std::vector< momentum::SkinnedLocatorConstraint > > | createSkinnedConstraintData (std::span< const std::vector< momentum::Marker > > markerData, const momentum::SkinnedLocatorList &locators) |
| |
|
| template<typename T > |
| MatrixX< T > | pseudoInverse (const MatrixX< T > &mat) |
| | Calculates the pseudo-inverse of a matrix.
|
| |
| template<typename T > |
| MatrixX< T > | pseudoInverse (const SparseMatrix< T > &mat) |
| | Calculates the pseudo-inverse of a sparse matrix.
|
| |
|
| ParameterSet | allParams () |
| | Creates a ParameterSet with all parameters set to active.
|
| |
| template<class T > |
| T | sqr (const T &x) |
| | Computes the square of a value.
|
| |
| template<typename T = float> |
| bool | isApprox (T l, T r, T eps=Eps< T >(1e-4, 1e-6)) noexcept |
| | Determines if two values are approximately equal within a given tolerance.
|
| |